3544 lines
112 KiB
C++
3544 lines
112 KiB
C++
// 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
|
|
//
|
|
/* CHANGE LOG:
|
|
04 apr 03 -- fixed bug in add_track that caused infinite loop
|
|
*/
|
|
|
|
#include "assert.h"
|
|
#include "stdlib.h"
|
|
#include "stdio.h"
|
|
#include "string.h"
|
|
#include "memory.h"
|
|
#include <iostream>
|
|
#include <fstream>
|
|
using namespace std;
|
|
#include "allegro.h"
|
|
#include "algrd_internal.h"
|
|
#include "algsmfrd_internal.h"
|
|
// #include "trace.h" -- only needed for debugging
|
|
#include "math.h"
|
|
#include "inttypes.h" // for PRId64
|
|
|
|
#define ALGDBG(x) ;
|
|
// #define ALGDBG(x) x; // turn on some printing for tracing/debugging
|
|
|
|
#define STREQL(x, y) (strcmp(x, y) == 0)
|
|
#define MAX(x, y) ((x) > (y) ? (x) : (y))
|
|
#define ROUND(x) ((int) ((x) + 0.5))
|
|
|
|
#ifdef max
|
|
#undef max
|
|
#endif
|
|
#define max(x,y) ((x)>(y)?(x):(y))
|
|
|
|
// 4311 is type cast ponter to long warning
|
|
// 4996 is warning against strcpy
|
|
// 4267 is size_t to long warning
|
|
#pragma warning(disable: 4311 4996 4267)
|
|
Alg_atoms symbol_table;
|
|
Serial_read_buffer Alg_track::ser_read_buf; // declare the static variables
|
|
Serial_write_buffer Alg_track::ser_write_buf;
|
|
|
|
bool within(double d1, double d2, double epsilon)
|
|
{
|
|
d1 -= d2;
|
|
return d1 < epsilon && d1 > -epsilon;
|
|
}
|
|
|
|
|
|
char *heapify(const char *s)
|
|
{
|
|
char *h = new char[strlen(s) + 1];
|
|
strcpy(h, s);
|
|
return h;
|
|
}
|
|
|
|
|
|
void Alg_atoms::expand()
|
|
{
|
|
maxlen = (maxlen + 5); // extra growth for small sizes
|
|
maxlen += (maxlen >> 2); // add 25%
|
|
Alg_attribute *new_atoms = new Alg_attribute[maxlen];
|
|
// now do copy
|
|
memcpy(new_atoms, atoms, len * sizeof(Alg_attribute));
|
|
if (atoms) delete[] atoms;
|
|
atoms = new_atoms;
|
|
}
|
|
|
|
|
|
// insert_new -- insert an attribute name and type
|
|
//
|
|
// attributes are stored as a string consisting of the type
|
|
// (a char) followed by the attribute name. This makes it
|
|
// easy to retrieve the type or the name or both.
|
|
//
|
|
Alg_attribute Alg_atoms::insert_new(const char *name, char attr_type)
|
|
{
|
|
if (len == maxlen) expand();
|
|
char *h = new char[strlen(name) + 2];
|
|
strcpy(h + 1, name);
|
|
*h = attr_type;
|
|
atoms[len++] = h;
|
|
return h;
|
|
}
|
|
|
|
|
|
Alg_attribute Alg_atoms::insert_attribute(Alg_attribute attr)
|
|
{
|
|
// should use hash algorithm
|
|
for (int i = 0; i < len; i++) {
|
|
if (STREQL(attr, atoms[i])) {
|
|
return atoms[i];
|
|
}
|
|
}
|
|
return insert_new(attr + 1, attr[0]);
|
|
}
|
|
|
|
|
|
Alg_attribute Alg_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] &&
|
|
STREQL(name, atoms[i] + 1)) {
|
|
return atoms[i];
|
|
}
|
|
}
|
|
return insert_new(name, attr_type);
|
|
}
|
|
|
|
|
|
void Alg_parameter::copy(Alg_parameter_ptr parm)
|
|
{
|
|
*this = *parm; // copy all fields
|
|
// if the value is a string, copy the string
|
|
if (attr_type() == 's') {
|
|
s = heapify(s);
|
|
}
|
|
}
|
|
|
|
|
|
void Alg_parameter::show()
|
|
{
|
|
switch (attr[0]) {
|
|
case 'r':
|
|
printf("%s:%g", attr_name(), r);
|
|
break;
|
|
case 's':
|
|
printf("%s:%s", attr_name(), s);
|
|
break;
|
|
case 'i':
|
|
printf("%s:%" PRId64, attr_name(), i);
|
|
break;
|
|
case 'l':
|
|
printf("%s:%s", attr_name(), (l ? "t" : "f"));
|
|
break;
|
|
case 'a':
|
|
printf("%s:%s", attr_name(), a);
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
Alg_parameter::~Alg_parameter()
|
|
{
|
|
if (attr_type() == 's' && s) {
|
|
delete[] s;
|
|
}
|
|
}
|
|
|
|
|
|
void Alg_parameters::insert_real(Alg_parameters **list, const char *name,
|
|
double r)
|
|
{
|
|
Alg_parameters_ptr a = new Alg_parameters(*list);
|
|
*list = a;
|
|
a->parm.set_attr(symbol_table.insert_string(name));
|
|
a->parm.r = r;
|
|
assert(a->parm.attr_type() == 'r');
|
|
}
|
|
|
|
|
|
void Alg_parameters::insert_string(Alg_parameters **list, const char *name,
|
|
const char *s)
|
|
{
|
|
Alg_parameters_ptr a = new Alg_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 Alg_parameters::insert_integer(Alg_parameters **list, const char *name,
|
|
int64_t i)
|
|
{
|
|
Alg_parameters_ptr a = new Alg_parameters(*list);
|
|
*list = a;
|
|
a->parm.set_attr(symbol_table.insert_string(name));
|
|
a->parm.i = i;
|
|
assert(a->parm.attr_type() == 'i');
|
|
}
|
|
|
|
|
|
void Alg_parameters::insert_logical(Alg_parameters **list, const char *name,
|
|
bool l)
|
|
{
|
|
Alg_parameters_ptr a = new Alg_parameters(*list);
|
|
*list = a;
|
|
a->parm.set_attr(symbol_table.insert_string(name));
|
|
a->parm.l = l;
|
|
assert(a->parm.attr_type() == 'l');
|
|
}
|
|
|
|
|
|
void Alg_parameters::insert_atom(Alg_parameters **list, const char *name,
|
|
const char *s)
|
|
{
|
|
Alg_parameters_ptr a = new Alg_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');
|
|
}
|
|
|
|
|
|
Alg_parameters *Alg_parameters::remove_key(Alg_parameters **list,
|
|
const char *name)
|
|
{
|
|
while (*list) {
|
|
if (STREQL((*list)->parm.attr_name(), name)) {
|
|
Alg_parameters_ptr p = *list;
|
|
*list = p->next;
|
|
p->next = NULL;
|
|
return p; // caller should free this pointer
|
|
}
|
|
list = &((*list)->next);
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
|
|
Alg_parameter_ptr Alg_parameters::find(Alg_attribute attr)
|
|
{
|
|
assert(attr);
|
|
Alg_parameters_ptr temp = this;
|
|
while (temp) {
|
|
if (temp->parm.attr == attr) {
|
|
return &(temp->parm);
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
|
|
int Alg_event::get_type_code()
|
|
{
|
|
if (!is_note()) {
|
|
const char* attr = get_attribute();
|
|
if (STREQL(attr, "gater")) // volume change
|
|
return ALG_GATE;
|
|
if (STREQL(attr, "bendr")) // pitch bend
|
|
return ALG_BEND;
|
|
if (strncmp(attr, "control", 7) == 0) // control change
|
|
// note that midi control changes have attributes of the form
|
|
// "control<n>" where n is the decimal number (as a character string)
|
|
// of the midi controller, e.g. control2 is the breath controller.
|
|
// We don't check for decimal numbers in the range 0-127, so any
|
|
// attribute that begins with "control" is an ALG_CONTROL:
|
|
return ALG_CONTROL;
|
|
if (STREQL(attr, "programi")) // program change
|
|
return ALG_PROGRAM;
|
|
if (STREQL(attr, "pressurer")) // pressure change
|
|
return ALG_PRESSURE;
|
|
if (STREQL(attr, "keysigi")) // key signature
|
|
return ALG_KEYSIG;
|
|
if (STREQL(attr, "timesig_numi")) // time signature numerator
|
|
return ALG_TIMESIG_NUM;
|
|
if (STREQL(attr, "timesig_deni")) // time signature denominator
|
|
return ALG_TIMESIG_DEN;
|
|
return ALG_OTHER;
|
|
}
|
|
return ALG_NOTE; // it is a note
|
|
}
|
|
|
|
|
|
void Alg_event::set_parameter(Alg_parameter_ptr new_parameter)
|
|
{
|
|
Alg_parameter_ptr parm;
|
|
if (is_note()) {
|
|
Alg_note_ptr note = (Alg_note_ptr) this;
|
|
parm = note->parameters->find(new_parameter->attr);
|
|
if (!parm) {
|
|
note->parameters = new Alg_parameters(note->parameters);
|
|
parm = &(note->parameters->parm);
|
|
}
|
|
} else { // update
|
|
Alg_update_ptr update = (Alg_update_ptr) this;
|
|
parm = &(update->parameter);
|
|
}
|
|
parm->copy(new_parameter); // copy entire parameter
|
|
}
|
|
|
|
|
|
void Alg_event::set_string_value(const char *a, const char *value)
|
|
{
|
|
assert(a); // must be non-null
|
|
Alg_attribute attr = symbol_table.insert_string(a);
|
|
assert(attr[0] == 's');
|
|
Alg_parameter parm;
|
|
parm.set_attr(attr);
|
|
parm.s = value;
|
|
set_parameter(&parm);
|
|
parm.s = NULL; // do this to prevent string from being freed
|
|
}
|
|
|
|
|
|
void Alg_event::set_real_value(const char *a, double value)
|
|
{
|
|
assert(a); // must be non-null
|
|
// attr is like a, but it has the type code prefixed for
|
|
// fast lookup, and it is a unique string in symbol_table
|
|
// e.g. a="attackr" -> attr="rattackr"
|
|
Alg_attribute attr = symbol_table.insert_string(a);
|
|
assert(attr[0] == 'r');
|
|
Alg_parameter parm;
|
|
parm.set_attr(attr);
|
|
parm.r = value;
|
|
set_parameter(&parm);
|
|
// since type is 'r' we don't have to NULL the string
|
|
}
|
|
|
|
|
|
void Alg_event::set_logical_value(const char *a, bool value)
|
|
{
|
|
assert(a); // must be non-null
|
|
Alg_attribute attr = symbol_table.insert_string(a);
|
|
assert(attr[0] == 'l');
|
|
Alg_parameter parm;
|
|
parm.set_attr(attr);
|
|
parm.l = value;
|
|
set_parameter(&parm);
|
|
// since type is 'l' we don't have to NULL the string
|
|
}
|
|
|
|
|
|
void Alg_event::set_integer_value(const char *a, int64_t value)
|
|
{
|
|
assert(a); // must be non-null
|
|
Alg_attribute attr = symbol_table.insert_string(a);
|
|
assert(attr[0] == 'i');
|
|
Alg_parameter parm;
|
|
parm.set_attr(attr);
|
|
parm.i = value;
|
|
set_parameter(&parm);
|
|
// since tpye is 'i' we don't have to NULL the string
|
|
}
|
|
|
|
|
|
void Alg_event::set_atom_value(const char *a, const char *value)
|
|
{
|
|
assert(a); // must be non-null
|
|
Alg_attribute attr = symbol_table.insert_string(a);
|
|
assert(attr[0] == 'a');
|
|
Alg_parameter parm;
|
|
parm.set_attr(attr);
|
|
parm.a = value;
|
|
set_parameter(&parm);
|
|
/* since type is 'a' we don't have to null the string */
|
|
}
|
|
|
|
|
|
float Alg_event::get_pitch()
|
|
{
|
|
assert(is_note());
|
|
Alg_note* note = (Alg_note *) this;
|
|
return note->pitch;
|
|
}
|
|
|
|
|
|
float Alg_event::get_loud()
|
|
{
|
|
assert(is_note());
|
|
Alg_note* note = (Alg_note *) this;
|
|
return note->loud;
|
|
}
|
|
|
|
|
|
double Alg_event::get_start_time()
|
|
{
|
|
assert(is_note());
|
|
Alg_note* note = (Alg_note *) this;
|
|
return note->time;
|
|
}
|
|
|
|
|
|
double Alg_event::get_end_time()
|
|
{
|
|
assert(is_note());
|
|
Alg_note* note = (Alg_note *) this;
|
|
return note->time + note->dur;
|
|
}
|
|
|
|
|
|
double Alg_event::get_duration()
|
|
{
|
|
assert(is_note());
|
|
Alg_note* note = (Alg_note *) this;
|
|
return note->dur;
|
|
}
|
|
|
|
|
|
void Alg_event::set_pitch(float p)
|
|
{
|
|
assert(is_note());
|
|
Alg_note* note = (Alg_note *) this;
|
|
note->pitch = p;
|
|
}
|
|
|
|
void Alg_event::set_loud(float l)
|
|
{
|
|
assert(is_note());
|
|
Alg_note *note = (Alg_note *) this;
|
|
note->loud = l;
|
|
}
|
|
|
|
|
|
void Alg_event::set_duration(double d)
|
|
{
|
|
assert(is_note());
|
|
Alg_note* note = (Alg_note *) this;
|
|
note->dur = d;
|
|
}
|
|
|
|
|
|
bool Alg_event::has_attribute(const char *a)
|
|
{
|
|
assert(is_note());
|
|
assert(a); // must be non-null
|
|
Alg_note* note = (Alg_note *) this;
|
|
Alg_attribute attr = symbol_table.insert_string(a);
|
|
Alg_parameter_ptr parm = note->parameters->find(attr);
|
|
return parm != NULL;
|
|
}
|
|
|
|
|
|
char Alg_event::get_attribute_type(const char *a)
|
|
{
|
|
assert(is_note());
|
|
assert(a);
|
|
return a[strlen(a) - 1];
|
|
}
|
|
|
|
|
|
const char *Alg_event::get_string_value(const char *a, const char *value)
|
|
{
|
|
assert(is_note());
|
|
assert(a); // must be non-null
|
|
Alg_note* note = (Alg_note *) this;
|
|
Alg_attribute attr = symbol_table.insert_string(a);
|
|
assert(a[0] == 's'); // must be of type string
|
|
Alg_parameter_ptr parm = note->parameters->find(attr);
|
|
if (parm) return parm->s;
|
|
return value;
|
|
}
|
|
|
|
|
|
double Alg_event::get_real_value(const char *a, double value)
|
|
{
|
|
assert(is_note());
|
|
assert(a);
|
|
Alg_note* note = (Alg_note *) this;
|
|
Alg_attribute attr = symbol_table.insert_string(a);
|
|
assert(a[0] == 'r'); // must be of type real
|
|
Alg_parameter_ptr parm = note->parameters->find(attr);
|
|
if (parm) return parm->r;
|
|
return value;
|
|
}
|
|
|
|
|
|
bool Alg_event::get_logical_value(const char *a, bool value)
|
|
{
|
|
assert(is_note());
|
|
assert(a);
|
|
Alg_note* note = (Alg_note *) this;
|
|
Alg_attribute attr = symbol_table.insert_string(a);
|
|
assert(a[0] == 'l'); // must be of type logical
|
|
Alg_parameter_ptr parm = note->parameters->find(attr);
|
|
if (parm) return parm->l;
|
|
return value;
|
|
}
|
|
|
|
|
|
int64_t Alg_event::get_integer_value(const char *a, int64_t value)
|
|
{
|
|
assert(is_note());
|
|
assert(a);
|
|
Alg_note* note = (Alg_note *) this;
|
|
Alg_attribute attr = symbol_table.insert_string(a);
|
|
assert(a[0] == 'i'); // must be of type integer
|
|
Alg_parameter_ptr parm = note->parameters->find(attr);
|
|
if (parm) return parm->i;
|
|
return value;
|
|
}
|
|
|
|
|
|
const char *Alg_event::get_atom_value(const char *a, const char *value)
|
|
{
|
|
assert(is_note());
|
|
assert(a);
|
|
Alg_note* note = (Alg_note *) this;
|
|
Alg_attribute attr = symbol_table.insert_string(a);
|
|
assert(a[0] == 'a'); // must be of type atom
|
|
Alg_parameter_ptr parm = note->parameters->find(attr);
|
|
if (parm) return parm->a;
|
|
// if default is a string, convert to an atom (unique
|
|
// string in symbol table) and return it
|
|
return (value == NULL ? NULL :
|
|
symbol_table.insert_string(value));
|
|
}
|
|
|
|
|
|
void Alg_event::delete_attribute(const char *a)
|
|
{
|
|
assert(is_note());
|
|
Alg_note* note = (Alg_note *) this;
|
|
Alg_parameters::remove_key(&(note->parameters), a);
|
|
}
|
|
|
|
|
|
const char *Alg_event::get_attribute()
|
|
// Note: this returns a string, not an Alg_attribute
|
|
{
|
|
assert(is_update());
|
|
Alg_update* update = (Alg_update *) this;
|
|
return update->parameter.attr_name();
|
|
}
|
|
|
|
|
|
char Alg_event::get_update_type()
|
|
{
|
|
assert(is_update());
|
|
Alg_update* update = (Alg_update *) this;
|
|
return update->parameter.attr_type();
|
|
}
|
|
|
|
|
|
const char *Alg_event::get_string_value()
|
|
{
|
|
assert(is_update());
|
|
Alg_update* update = (Alg_update *) this;
|
|
assert(get_update_type() == 's');
|
|
return update->parameter.s;
|
|
}
|
|
|
|
|
|
double Alg_event::get_real_value()
|
|
{
|
|
assert(is_update());
|
|
Alg_update* update = (Alg_update *) this;
|
|
assert(get_update_type() == 'r');
|
|
return update->parameter.r;
|
|
}
|
|
|
|
|
|
bool Alg_event::get_logical_value()
|
|
{
|
|
assert(is_update());
|
|
Alg_update* update = (Alg_update *) this;
|
|
assert(get_update_type() == 'l');
|
|
return update->parameter.l;
|
|
}
|
|
|
|
|
|
int64_t Alg_event::get_integer_value()
|
|
{
|
|
assert(is_update());
|
|
Alg_update* update = (Alg_update *) this;
|
|
assert(get_update_type() == 'i');
|
|
return update->parameter.i;
|
|
}
|
|
|
|
|
|
const char *Alg_event::get_atom_value()
|
|
{
|
|
assert(is_update());
|
|
Alg_update* update = (Alg_update *) this;
|
|
assert(get_update_type() == 'a');
|
|
return update->parameter.a;
|
|
}
|
|
|
|
|
|
bool Alg_event::overlap(double t, double len, bool all)
|
|
{
|
|
// event starts within region
|
|
if (time >= t && time <= t + len - ALG_EPS)
|
|
return true;
|
|
if (all && is_note()) {
|
|
double dur = ((Alg_note_ptr) this)->dur;
|
|
// note overlaps with region
|
|
if (time < t && time + dur - ALG_EPS > t)
|
|
return true;
|
|
}
|
|
// does not overlap
|
|
return false;
|
|
}
|
|
|
|
|
|
Alg_note::Alg_note(Alg_note_ptr note)
|
|
{
|
|
*this = *note; // copy all fields
|
|
// parameters is now a shared pointer. We need to copy the
|
|
// parameters
|
|
Alg_parameters_ptr next_parm_ptr = parameters;
|
|
while (next_parm_ptr) {
|
|
Alg_parameters_ptr new_parms = new Alg_parameters(next_parm_ptr->next);
|
|
new_parms->parm.copy(&(next_parm_ptr->parm)); // copy the attribute and value
|
|
next_parm_ptr = new_parms->next;
|
|
}
|
|
}
|
|
|
|
|
|
Alg_note::~Alg_note()
|
|
{
|
|
while (parameters) {
|
|
Alg_parameters_ptr to_delete = parameters;
|
|
parameters = parameters->next;
|
|
delete to_delete;
|
|
}
|
|
}
|
|
|
|
|
|
void Alg_note::show()
|
|
{
|
|
printf("Alg_note: time %g, chan %d, dur %g, key %d, "
|
|
"pitch %g, loud %g, attributes ",
|
|
time, chan, dur, key, pitch, loud);
|
|
Alg_parameters_ptr parms = parameters;
|
|
while (parms) {
|
|
parms->parm.show();
|
|
printf(" ");
|
|
parms = parms->next;
|
|
}
|
|
printf("\n");
|
|
}
|
|
|
|
|
|
Alg_update::Alg_update(Alg_update_ptr update)
|
|
{
|
|
*this = *update; // copy all fields
|
|
// parameter requires careful copy to possibly duplicate string value:
|
|
this->parameter.copy(&(update->parameter));
|
|
}
|
|
|
|
|
|
void Alg_update::show()
|
|
{
|
|
printf("Alg_update: ");
|
|
parameter.show();
|
|
printf("\n");
|
|
}
|
|
|
|
|
|
void Alg_events::expand()
|
|
{
|
|
maxlen = (maxlen + 5); // extra growth for small sizes
|
|
maxlen += (maxlen >> 2); // add 25%
|
|
Alg_event_ptr *new_events = new Alg_event_ptr[maxlen];
|
|
// now do copy
|
|
memcpy(new_events, events, len * sizeof(Alg_event_ptr));
|
|
if (events) delete[] events;
|
|
events = new_events;
|
|
}
|
|
|
|
|
|
void Alg_events::insert(Alg_event_ptr event)
|
|
{
|
|
if (maxlen <= len) {
|
|
expand();
|
|
}
|
|
// Note: if the new event is the last one, the assignment
|
|
// events[i] = event; (below) will never execute, so just
|
|
// in case, we do the assignment here. events[len] will
|
|
// be replaced during the memmove() operation below if
|
|
// this is not the last event.
|
|
events[len] = event;
|
|
len++;
|
|
// find insertion point: (this could be a binary search)
|
|
for (int i = 0; i < len; i++) {
|
|
if (events[i]->time > event->time) {
|
|
// insert event at i
|
|
memmove(&events[i + 1], &events[i],
|
|
sizeof(Alg_event_ptr) * (len - i - 1));
|
|
events[i] = event;
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
Alg_event_ptr Alg_events::uninsert(long index)
|
|
{
|
|
assert(0 <= index && index < len);
|
|
Alg_event_ptr event = events[index];
|
|
//printf("memmove: %x from %x (%d)\n", events + index, events + index + 1,
|
|
// sizeof(Alg_event_ptr) * (len - index - 1));
|
|
memmove(events + index, events + index + 1,
|
|
sizeof(Alg_event_ptr) * (len - index - 1));
|
|
len--;
|
|
return event;
|
|
}
|
|
|
|
|
|
void Alg_events::append(Alg_event_ptr event)
|
|
{
|
|
if (maxlen <= len) {
|
|
expand();
|
|
}
|
|
events[len++] = event;
|
|
// keep track of last note_off time
|
|
if (event->is_note()) {
|
|
Alg_note_ptr note = (Alg_note_ptr) event;
|
|
double note_off = note->time + note->dur;
|
|
if (note_off > last_note_off)
|
|
last_note_off = note_off;
|
|
}
|
|
}
|
|
|
|
|
|
Alg_events::~Alg_events()
|
|
{
|
|
assert(!in_use);
|
|
// individual events are not deleted, only the array
|
|
if (events) {
|
|
delete[] events;
|
|
}
|
|
}
|
|
|
|
|
|
Alg_event_list::Alg_event_list(Alg_track *owner)
|
|
{
|
|
events_owner = owner;
|
|
sequence_number = owner->sequence_number;
|
|
beat_dur = 0.0; real_dur = 0.0; type = 'e';
|
|
}
|
|
|
|
|
|
Alg_event_ptr &Alg_event_list::operator [](int i)
|
|
{
|
|
assert(i >= 0 && i < len);
|
|
return events[i];
|
|
}
|
|
|
|
|
|
Alg_event_list::~Alg_event_list()
|
|
{
|
|
// note that the events contained in the list are not destroyed
|
|
}
|
|
|
|
|
|
void Alg_event_list::set_start_time(Alg_event *event, double t)
|
|
{
|
|
// For Alg_event_list, find the owner and do the update there
|
|
// For Alg_track, change the time and move the event to the right place
|
|
// For Alg_seq, find the track and do the update there
|
|
|
|
long index, i;
|
|
Alg_track_ptr track_ptr;
|
|
if (type == 'e') { // this is an Alg_event_list
|
|
// make sure the owner has not changed its event set
|
|
assert(events_owner &&
|
|
sequence_number == events_owner->sequence_number);
|
|
// do the update on the owner
|
|
events_owner->set_start_time(event, t);
|
|
return;
|
|
} else if (type == 't') { // this is an Alg_track
|
|
// find the event in the track
|
|
track_ptr = (Alg_track_ptr) this;
|
|
// this should be a binary search since events are in time order
|
|
// probably there should be member function to do the search
|
|
for (index = 0; index < length(); index++) {
|
|
if ((*track_ptr)[index] == event) goto found_event;
|
|
}
|
|
} else { // type == 's', an Alg_seq
|
|
Alg_seq_ptr seq = (Alg_seq_ptr) this;
|
|
for (i = 0; i < seq->tracks(); i++) {
|
|
track_ptr = seq->track(i);
|
|
// if you implemented binary search, you could call it
|
|
// instead of this loop too.
|
|
for (index = 0; index < track_ptr->length(); index++) {
|
|
if ((*track_ptr)[index] == event) goto found_event;
|
|
}
|
|
}
|
|
}
|
|
assert(false); // event not found seq or track!
|
|
found_event:
|
|
// at this point, track[index] == event
|
|
// we could be clever and figure out exactly what notes to move
|
|
// but it is simpler to just remove the event and reinsert it:
|
|
track_ptr->uninsert(index);
|
|
event->time = t;
|
|
track_ptr->insert(event);
|
|
}
|
|
|
|
|
|
void Alg_beats::expand()
|
|
{
|
|
maxlen = (maxlen + 5); // extra growth for small sizes
|
|
maxlen += (maxlen >> 2); // add 25%
|
|
Alg_beat_ptr new_beats = new Alg_beat[maxlen];
|
|
// now do copy
|
|
memcpy(new_beats, beats, len * sizeof(Alg_beat));
|
|
if (beats) delete[] beats;
|
|
beats = new_beats;
|
|
}
|
|
|
|
|
|
void Alg_beats::insert(long i, Alg_beat_ptr beat)
|
|
{
|
|
assert(i >= 0 && i <= len);
|
|
if (maxlen <= len) {
|
|
expand();
|
|
}
|
|
memmove(&beats[i + 1], &beats[i], sizeof(Alg_beat) * (len - i));
|
|
memcpy(&beats[i], beat, sizeof(Alg_beat));
|
|
len++;
|
|
}
|
|
|
|
|
|
Alg_time_map::Alg_time_map(Alg_time_map *map)
|
|
{
|
|
refcount = 0;
|
|
assert(map->beats[0].beat == 0 && map->beats[0].time == 0);
|
|
assert(map->beats.len > 0);
|
|
// new_beats[0] = map->beats[0];
|
|
// this is commented because
|
|
// both new_beats[0] and map->beats[0] should be (0, 0)
|
|
for (int i = 1; i < map->beats.len; i++) {
|
|
beats.insert(i, &map->beats[i]);
|
|
}
|
|
last_tempo = map->last_tempo;
|
|
last_tempo_flag = map->last_tempo_flag;
|
|
}
|
|
|
|
|
|
void Alg_time_map::show()
|
|
{
|
|
printf("Alg_time_map: ");
|
|
for (int i = 0; i < beats.len; i++) {
|
|
Alg_beat &b = beats[i];
|
|
printf("(%g, %g) ", b.time, b.beat);
|
|
}
|
|
printf("last tempo: %g\n", last_tempo);
|
|
}
|
|
|
|
|
|
long Alg_time_map::locate_time(double time)
|
|
{
|
|
int i = 0;
|
|
while ((i < beats.len) && (time > beats[i].time)) {
|
|
i++;
|
|
}
|
|
return i;
|
|
}
|
|
|
|
|
|
long Alg_time_map::locate_beat(double beat)
|
|
{
|
|
int i = 0;
|
|
while ((i < beats.len) && (beat > beats[i].beat)) {
|
|
i++;
|
|
}
|
|
return i;
|
|
}
|
|
|
|
|
|
double Alg_time_map::beat_to_time(double beat)
|
|
{
|
|
Alg_beat_ptr mbi;
|
|
Alg_beat_ptr mbi1;
|
|
if (beat <= 0) {
|
|
return beat;
|
|
}
|
|
int i = locate_beat(beat);
|
|
// case 1: beat is between two time/beat pairs
|
|
if (0 < i && i < beats.len) {
|
|
mbi = &beats[i - 1];
|
|
mbi1 = &beats[i];
|
|
// case 2: beat is beyond last time/beat pair
|
|
} else 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 * 60.0 / ALG_DEFAULT_BPM;
|
|
// so we use that as default allegro tempo too
|
|
} else {
|
|
mbi = &beats[i - 2];
|
|
mbi1 = &beats[i - 1];
|
|
}
|
|
// case 3: beat is at time 0
|
|
} else /* if (i == 0) */ {
|
|
return beats[0].time;
|
|
}
|
|
// whether we 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 Alg_time_map::time_to_beat(double time)
|
|
{
|
|
Alg_beat_ptr mbi;
|
|
Alg_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 * (ALG_DEFAULT_BPM / 60.0);
|
|
} 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 Alg_time_map::insert_beat(double time, double beat)
|
|
{
|
|
int i = locate_time(time); // i is insertion point
|
|
if (i < beats.len && within(beats[i].time, time, 0.000001)) {
|
|
// replace beat if time is already in the map
|
|
beats[i].beat = beat;
|
|
} else {
|
|
Alg_beat point;
|
|
point.beat = beat;
|
|
point.time = time;
|
|
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;
|
|
if (j == 0) j = 1; // do not adjust beats[0]
|
|
while (j < beats.len &&
|
|
beats[j - 1].beat + 0.000001 >= beats[j].beat) {
|
|
beats[j].beat = beats[j - 1].beat + 0.000001;
|
|
j++;
|
|
}
|
|
}
|
|
|
|
|
|
bool Alg_time_map::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;
|
|
double time = beat_to_time(beat);
|
|
long i = locate_time(time);
|
|
if (i >= beats.len || !within(beats[i].time, time, 0.000001)) {
|
|
insert_beat(time, beat);
|
|
}
|
|
// now i is index of beat where tempo will change
|
|
if (i == beats.len - 1) {
|
|
last_tempo = tempo;
|
|
// printf("last_tempo to %g\n", last_tempo);
|
|
last_tempo_flag = true;
|
|
} else { // adjust all future beats
|
|
// compute the difference in beats
|
|
double diff = beats[i + 1].beat - beats[i].beat;
|
|
// convert beat difference to seconds at new tempo
|
|
diff = diff / tempo;
|
|
// figure out old time difference:
|
|
double old_diff = beats[i + 1].time - time;
|
|
// compute difference too
|
|
diff = diff - old_diff;
|
|
// apply new_diff to score and beats
|
|
i++;
|
|
while (i < beats.len) {
|
|
beats[i].time = beats[i].time + diff;
|
|
i++;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
|
|
double Alg_time_map::get_tempo(double beat)
|
|
{
|
|
Alg_beat_ptr mbi;
|
|
Alg_beat_ptr mbi1;
|
|
// if beat < 0, there is probably an error; return something nice anyway
|
|
if (beat < 0) return ALG_DEFAULT_BPM / 60.0;
|
|
long i = locate_beat(beat);
|
|
// this code is similar to beat_to_time() so far, but we want to get
|
|
// beyond beat if possible because we want the tempo FOLLOWING beat
|
|
// (Consider the case beat == 0.0)
|
|
if (i < beats.len && beat >= beats[i].beat) i++;
|
|
// case 1: beat is between two time/beat pairs
|
|
if (i < beats.len) {
|
|
mbi = &beats[i - 1];
|
|
mbi1 = &beats[i];
|
|
// case 2: beat is beyond last time/beat pair
|
|
} else /* if (i == beats.len) */ {
|
|
if (last_tempo_flag) {
|
|
return last_tempo;
|
|
} else if (i == 1) {
|
|
return ALG_DEFAULT_BPM / 60.0;
|
|
} else {
|
|
mbi = &beats[i - 2];
|
|
mbi1 = &beats[i - 1];
|
|
}
|
|
}
|
|
double time_dif = mbi1->time - mbi->time;
|
|
double beat_dif = mbi1->beat - mbi->beat;
|
|
return beat_dif / time_dif;
|
|
}
|
|
|
|
|
|
bool Alg_time_map::set_tempo(double tempo, double start_beat, double end_beat)
|
|
{
|
|
if (start_beat >= end_beat) return false;
|
|
// algorithm: insert a beat event if necessary at start_beat
|
|
// and at end_beat
|
|
// delete intervening map elements
|
|
// change the tempo
|
|
insert_beat(beat_to_time(start_beat), start_beat);
|
|
insert_beat(beat_to_time(end_beat), end_beat);
|
|
long start_x = locate_beat(start_beat) + 1;
|
|
long stop_x = locate_beat(end_beat);
|
|
while (stop_x < beats.len) {
|
|
beats[start_x] = beats[stop_x];
|
|
start_x++;
|
|
stop_x++;
|
|
}
|
|
beats.len = start_x; // truncate the map to new length
|
|
return insert_tempo(tempo, start_beat);
|
|
}
|
|
|
|
|
|
bool Alg_time_map::stretch_region(double b0, double b1, double dur)
|
|
{
|
|
// find current duration
|
|
double t0 = beat_to_time(b0);
|
|
double t1 = beat_to_time(b1);
|
|
double old_dur = t1 - t0;
|
|
if (old_dur <= 0 || dur <= 0) return false;
|
|
double scale = dur / old_dur; // larger scale => slower
|
|
// insert a beat if necessary at b0 and b1
|
|
insert_beat(t0, b0);
|
|
insert_beat(t1, b1);
|
|
long start_x = locate_beat(b0);
|
|
long stop_x = locate_beat(b1);
|
|
double orig_time = beats[start_x].time;
|
|
double prev_time = orig_time;
|
|
for (int i = start_x + 1; i < beats.len; i++) {
|
|
double delta = beats[i].time - orig_time;
|
|
if (i <= stop_x) { // change tempo to next Alg_beat
|
|
delta *= scale;
|
|
}
|
|
orig_time = beats[i].time;
|
|
prev_time += delta;
|
|
beats[i].time = prev_time;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
|
|
void Alg_time_map::trim(double start, double end, bool units_are_seconds)
|
|
{
|
|
// extract the time map from start to end and shift to time zero
|
|
// start and end are time in seconds if units_are_seconds is true
|
|
int i = 0; // index into beats
|
|
int start_index; // index of first breakpoint after start
|
|
int count = 1;
|
|
double initial_beat = start;
|
|
double final_beat = end;
|
|
if (units_are_seconds) {
|
|
initial_beat = time_to_beat(start);
|
|
final_beat = time_to_beat(end);
|
|
} else {
|
|
start = beat_to_time(initial_beat);
|
|
end = beat_to_time(final_beat);
|
|
}
|
|
while (i < length() && beats[i].time < start) i++;
|
|
// now i is index into beats of the first breakpoint after start
|
|
// beats[0] is (0,0) and remains that way
|
|
// copy beats[start_index] to beats[1], etc.
|
|
// skip any beats at or near (start,initial_beat), using count
|
|
// to keep track of how many entries there are
|
|
start_index = i;
|
|
while (i < length() && beats[i].time < end) {
|
|
if (beats[i].time - start > ALG_EPS &&
|
|
beats[i].beat - initial_beat > ALG_EPS) {
|
|
beats[i].time = beats[i].time - start;
|
|
beats[i].beat = beats[i].beat - initial_beat;
|
|
beats[i - start_index + 1] = beats[i];
|
|
count = count + 1;
|
|
} else {
|
|
start_index = start_index + 1;
|
|
}
|
|
i = i + 1;
|
|
}
|
|
// set last tempo data
|
|
// we last examined beats[i-1] and copied it to
|
|
// beats[i - start_index]. Next tempo should come
|
|
// from beats[i] and store in beats[i - start_index + 1]
|
|
// case 1: there is at least one breakpoint beyond end
|
|
// => interpolate to put a breakpoint at end
|
|
// case 2: no more breakpoints => set last tempo data
|
|
if (i < length()) {
|
|
// we know beats[i].time >= end, so case 1 applies
|
|
beats[i - start_index + 1].time = end - start;
|
|
beats[i - start_index + 1].beat = final_beat - initial_beat;
|
|
count = count + 1;
|
|
}
|
|
// else we'll just use stored last tempo (if any)
|
|
beats.len = count;
|
|
}
|
|
|
|
|
|
void Alg_time_map::cut(double start, double len, bool units_are_seconds)
|
|
{
|
|
// remove portion of time map from start to start + len,
|
|
// shifting the tail left by len. start and len are in whatever
|
|
// units the score is in. If you cut the time_map as well as cut
|
|
// the tracks of the sequence, then sequences will preserve the
|
|
// association between tempo changes and events
|
|
double end = start + len;
|
|
double initial_beat = start;
|
|
double final_beat = end;
|
|
int i = 0;
|
|
|
|
if (units_are_seconds) {
|
|
initial_beat = time_to_beat(start);
|
|
final_beat = time_to_beat(end);
|
|
} else {
|
|
start = beat_to_time(initial_beat);
|
|
end = beat_to_time(final_beat);
|
|
len = end - start;
|
|
}
|
|
double beat_len = final_beat - initial_beat;
|
|
|
|
while (i < length() && beats[i].time < start - ALG_EPS) {
|
|
i = i + 1;
|
|
}
|
|
|
|
// if no beats exist at or after start, just return; nothing to cut
|
|
if (i == length()) return;
|
|
|
|
// now i is index into beats of the first breakpoint on or
|
|
// after start, insert (start, initial_beat) in map
|
|
if (i < length() && within(beats[i].time, start, ALG_EPS)) {
|
|
// perterb time map slightly (within alg_eps) to place
|
|
// break point exactly at the start time
|
|
beats[i].time = start;
|
|
beats[i].beat = initial_beat;
|
|
} else {
|
|
Alg_beat point(start, initial_beat);
|
|
beats.insert(i, &point);
|
|
}
|
|
// now, we're correct up to beats[i] and beats[i] happens at start.
|
|
// find first beat after end so we can start shifting from there
|
|
i = i + 1;
|
|
int start_index = i;
|
|
while (i < length() && beats[i].time < end + ALG_EPS) i++;
|
|
// now beats[i] is the next point to be included in beats
|
|
// but from i onward, we must shift by (-len, -beat_len)
|
|
while (i < length()) {
|
|
Alg_beat &b = beats[i];
|
|
b.time = b.time - len;
|
|
b.beat = b.beat - beat_len;
|
|
beats[start_index] = b;
|
|
i = i + 1;
|
|
start_index = start_index + 1;
|
|
}
|
|
beats.len = start_index;
|
|
}
|
|
|
|
|
|
void Alg_time_map::paste(double beat, Alg_track *tr)
|
|
{
|
|
// insert a given time map at a given time and dur (in beats)
|
|
Alg_time_map_ptr from_map = tr->get_time_map();
|
|
// printf("time map paste\nfrom map\n");
|
|
// from_map->show();
|
|
// printf("to map\n");
|
|
// show();
|
|
Alg_beats &from = from_map->beats;
|
|
double time = beat_to_time(beat);
|
|
// Locate the point at which dur occurs
|
|
double dur = tr->get_beat_dur();
|
|
double tr_end_time = from_map->beat_to_time(dur);
|
|
// add offset to make room for insert
|
|
int i = locate_beat(beat);
|
|
while (i < length()) {
|
|
beats[i].beat += dur;
|
|
beats[i].time += tr_end_time;
|
|
i++;
|
|
}
|
|
// printf("after opening up\n");
|
|
// show();
|
|
// insert point at beginning and end of paste
|
|
insert_beat(time, beat);
|
|
// printf("after beginning point insert\n");
|
|
// show();
|
|
// insert_beat(time + tr_end_time, beat + dur);
|
|
// printf("after ending point insert\n");
|
|
// show();
|
|
int j = from_map->locate_beat(dur);
|
|
for (i = 0; i < j; i++) {
|
|
insert_beat(from[i].time + time, // shift by time
|
|
from[i].beat + beat); // and beat
|
|
}
|
|
// printf("after inserts\n");
|
|
show();
|
|
}
|
|
|
|
|
|
void Alg_time_map::insert_time(double start, double len)
|
|
{
|
|
// find time,beat pair that determines tempo at start
|
|
// compute beat offset = (delta beat / delta time) * len
|
|
// add len,beat offset to each following Alg_beat
|
|
// show();
|
|
int i = locate_time(start); // start <= beats[i].time
|
|
if (beats[i].time == start) i++; // start < beats[i].time
|
|
// case 1: between beats
|
|
if (i > 0 && i < length()) {
|
|
double beat_offset = len * (beats[i].beat - beats[i-1].beat) /
|
|
(beats[i].time - beats[i-1].time);
|
|
while (i < length()) {
|
|
beats[i].beat += beat_offset;
|
|
beats[i].time += len;
|
|
i++;
|
|
}
|
|
} // otherwise, last tempo is in effect; nothing to do
|
|
// printf("time_map AFTER INSERT\n");
|
|
// show();
|
|
}
|
|
|
|
|
|
void Alg_time_map::insert_beats(double start, double len)
|
|
{
|
|
int i = locate_beat(start); // start <= beats[i].beat
|
|
if (beats[i].beat == start) i++;
|
|
if (i > 0 && i < length()) {
|
|
double time_offset = len * (beats[i].time - beats[i-1].time) /
|
|
(beats[i].beat - beats[i-1].beat);
|
|
while (i < length()) {
|
|
beats[i].time += time_offset;
|
|
beats[i].beat += len;
|
|
i++;
|
|
}
|
|
} // otherwise, last tempo is in effect; nothing to do
|
|
// printf("time_map AFTER INSERT\n");
|
|
// show();
|
|
}
|
|
|
|
|
|
Alg_track::Alg_track(Alg_time_map *map, bool seconds)
|
|
{
|
|
type = 't';
|
|
time_map = NULL;
|
|
units_are_seconds = seconds;
|
|
set_time_map(map);
|
|
}
|
|
|
|
|
|
Alg_event_ptr Alg_track::copy_event(Alg_event_ptr event)
|
|
{
|
|
Alg_event *new_event;
|
|
if (event->is_note()) {
|
|
new_event = new Alg_note((Alg_note_ptr) event);
|
|
} else { // update
|
|
new_event = new Alg_update((Alg_update_ptr) event);
|
|
}
|
|
return new_event;
|
|
}
|
|
|
|
|
|
Alg_track::Alg_track(Alg_track &track)
|
|
{
|
|
type = 't';
|
|
time_map = NULL;
|
|
for (int i = 0; i < track.length(); i++) {
|
|
append(copy_event(track.events[i]));
|
|
}
|
|
set_time_map(track.time_map);
|
|
units_are_seconds = track.units_are_seconds;
|
|
}
|
|
|
|
|
|
Alg_track::Alg_track(Alg_event_list_ref event_list, Alg_time_map_ptr map,
|
|
bool units_are_seconds)
|
|
{
|
|
type = 't';
|
|
time_map = NULL;
|
|
for (int i = 0; i < event_list.length(); i++) {
|
|
append(copy_event(event_list[i]));
|
|
}
|
|
set_time_map(map);
|
|
this->units_are_seconds = units_are_seconds;
|
|
}
|
|
|
|
|
|
void Alg_track::serialize(void **buffer, long *bytes)
|
|
{
|
|
// first determine whether this is a seq or a track.
|
|
// if it is a seq, then we will write the time map and a set of tracks
|
|
// if it is a track, we just write the track data and not the time map
|
|
//
|
|
// The code will align doubles on ALIGN boundaries, and longs and
|
|
// floats are aligned to multiples of 4 bytes.
|
|
//
|
|
// The format for a seq is:
|
|
// 'ALGS' -- indicates that this is a sequence
|
|
// long length of all seq data in bytes starting with 'ALGS'
|
|
// long channel_offset_per_track
|
|
// long units_are_seconds
|
|
// time_map:
|
|
// double last_tempo
|
|
// long last_tempo_flag
|
|
// long len -- number of tempo changes
|
|
// for each tempo change (Alg_beat):
|
|
// double time
|
|
// double beat
|
|
// time_sigs:
|
|
// long len -- number of time_sigs
|
|
// long pad
|
|
// for each time signature:
|
|
// double beat
|
|
// double num
|
|
// double den
|
|
// tracks:
|
|
// long len -- number of tracks
|
|
// long pad
|
|
// for each track:
|
|
// 'ALGT' -- indicates this is a track
|
|
// long length of all track data in bytes starting with 'ALGT'
|
|
// long units_are_seconds
|
|
// double beat_dur
|
|
// double real_dur
|
|
// long len -- number of events
|
|
// for each event:
|
|
// long selected
|
|
// long type
|
|
// long key
|
|
// long channel
|
|
// double time
|
|
// if this is a note:
|
|
// double pitch
|
|
// double dur
|
|
// double loud
|
|
// long len -- number of parameters
|
|
// for each parameter:
|
|
// char attribute[] with zero pad to ALIGN
|
|
// one of the following, depending on type:
|
|
// double r
|
|
// char s[] terminated by zero
|
|
// long i
|
|
// long l
|
|
// char a[] terminated by zero
|
|
// zero pad to ALIGN
|
|
// else if this is an update
|
|
// (same representation as parameter above)
|
|
// zero pad to ALIGN
|
|
//
|
|
// The format for a track is given within the Seq format above
|
|
assert(get_type() == 't');
|
|
ser_write_buf.init_for_write();
|
|
serialize_track();
|
|
*buffer = ser_write_buf.to_heap(bytes);
|
|
}
|
|
|
|
|
|
void Alg_seq::serialize(void **buffer, long *bytes)
|
|
{
|
|
assert(get_type() == 's');
|
|
ser_write_buf.init_for_write();
|
|
serialize_seq();
|
|
*buffer = ser_write_buf.to_heap(bytes);
|
|
ALGDBG(int chksum = 0; unsigned char *data = (unsigned char *) *buffer);
|
|
// not a reliable checksum, just a sanity check:
|
|
ALGDBG(for (int i = 0; i < *bytes; i++) chksum += data[i]);
|
|
ALGDBG(printf("Alg_seq::serialize %ld bytes, chksum %d\n", *bytes, chksum));
|
|
}
|
|
|
|
|
|
// make sure we can write at least needed more bytes into buffer
|
|
void Serial_write_buffer::check_buffer(long needed)
|
|
{
|
|
needed += (ptr - buffer);
|
|
assert(needed > 0); // did we overflow?
|
|
if (len < needed) { // do we need more space?
|
|
long new_len = len * 2; // exponential growth is important
|
|
assert(new_len >= 0); // did we overflow?
|
|
// initially, length is zero, so bump new_len to a starting value
|
|
if (new_len == 0) new_len = 1024;
|
|
// make sure new_len is as big as needed
|
|
if (needed > new_len) new_len = needed;
|
|
assert(new_len <= 0x7FFFFFFF); // we use 32-bit offsets
|
|
char *new_buffer = new char[new_len]; // allocate space
|
|
ptr = new_buffer + (ptr - buffer); // relocate ptr to new buffer
|
|
if (len > 0) { // we had a buffer already
|
|
memcpy(new_buffer, buffer, len); // copy from old buffer
|
|
delete buffer; // free old buffer
|
|
}
|
|
buffer = new_buffer; // update buffer information
|
|
len = new_len;
|
|
}
|
|
}
|
|
|
|
|
|
void Alg_seq::serialize_seq()
|
|
{
|
|
int i; // loop counters
|
|
// we can easily compute how much buffer space we need until we
|
|
// get to tracks, so expand at least that much
|
|
long needed = 64 + 16 * time_map->beats.len + 24 * time_sig.length();
|
|
ser_write_buf.check_buffer(needed);
|
|
ser_write_buf.set_char('A');
|
|
ser_write_buf.set_char('L');
|
|
ser_write_buf.set_char('G');
|
|
ser_write_buf.set_char('S');
|
|
long length_offset = ser_write_buf.get_posn();
|
|
ser_write_buf.set_int32(0); // leave room to come back and write length
|
|
ser_write_buf.set_int32(channel_offset_per_track);
|
|
ser_write_buf.set_int32(units_are_seconds);
|
|
ser_write_buf.set_double(beat_dur);
|
|
ser_write_buf.set_double(real_dur);
|
|
ser_write_buf.set_double(time_map->last_tempo);
|
|
ser_write_buf.set_int32(time_map->last_tempo_flag);
|
|
ser_write_buf.set_int32(time_map->beats.len);
|
|
for (i = 0; i < time_map->beats.len; i++) {
|
|
ser_write_buf.set_double(time_map->beats[i].time);
|
|
ser_write_buf.set_double(time_map->beats[i].beat);
|
|
}
|
|
ser_write_buf.set_int32(time_sig.length());
|
|
ser_write_buf.pad();
|
|
for (i = 0; i < time_sig.length(); i++) {
|
|
ser_write_buf.set_double(time_sig[i].beat);
|
|
ser_write_buf.set_double(time_sig[i].num);
|
|
ser_write_buf.set_double(time_sig[i].den);
|
|
}
|
|
ser_write_buf.set_int32(tracks());
|
|
ser_write_buf.pad();
|
|
for (i = 0; i < tracks(); i++) {
|
|
track(i)->serialize_track();
|
|
}
|
|
// do not include ALGS, include padding at end
|
|
ser_write_buf.store_int32(length_offset,
|
|
ser_write_buf.get_posn() - length_offset);
|
|
}
|
|
|
|
|
|
void Alg_track::serialize_track()
|
|
{
|
|
// to simplify the code, copy from parameter addresses to locals
|
|
int j;
|
|
ser_write_buf.check_buffer(32);
|
|
ser_write_buf.set_char('A');
|
|
ser_write_buf.set_char('L');
|
|
ser_write_buf.set_char('G');
|
|
ser_write_buf.set_char('T');
|
|
long length_offset = ser_write_buf.get_posn(); // save location for track length
|
|
ser_write_buf.set_int32(0); // room to write track length
|
|
ser_write_buf.set_int32(units_are_seconds);
|
|
ser_write_buf.set_double(beat_dur);
|
|
ser_write_buf.set_double(real_dur);
|
|
ser_write_buf.set_int32(len);
|
|
for (j = 0; j < len; j++) {
|
|
ser_write_buf.check_buffer(24);
|
|
Alg_event *event = (*this)[j];
|
|
ser_write_buf.set_int32(event->get_selected());
|
|
assert(event->get_type() == 'n' || event->get_type() == 'u');
|
|
ser_write_buf.set_int32(event->get_type());
|
|
ser_write_buf.set_int32(event->get_identifier());
|
|
ser_write_buf.set_int32(event->chan);
|
|
ser_write_buf.set_double(event->time);
|
|
if (event->is_note()) {
|
|
ser_write_buf.check_buffer(20);
|
|
Alg_note *note = (Alg_note *) event;
|
|
ser_write_buf.set_float(note->pitch);
|
|
ser_write_buf.set_float(note->loud);
|
|
ser_write_buf.set_double(note->dur);
|
|
long parm_num_offset = ser_write_buf.get_posn();
|
|
long parm_num = 0;
|
|
ser_write_buf.set_int32(0); // placeholder for no. parameters
|
|
Alg_parameters_ptr parms = note->parameters;
|
|
while (parms) {
|
|
serialize_parameter(&(parms->parm));
|
|
parms = parms->next;
|
|
parm_num++;
|
|
}
|
|
ser_write_buf.store_int32(parm_num_offset, parm_num);
|
|
} else {
|
|
assert(event->is_update());
|
|
Alg_update *update = (Alg_update *) event;
|
|
serialize_parameter(&(update->parameter));
|
|
}
|
|
ser_write_buf.check_buffer(7); // maximum padding possible
|
|
ser_write_buf.pad();
|
|
}
|
|
// write length, not including ALGT, including padding at end
|
|
ser_write_buf.store_int32(length_offset,
|
|
ser_write_buf.get_posn() - length_offset);
|
|
}
|
|
|
|
|
|
void Alg_track::serialize_parameter(Alg_parameter *parm)
|
|
{
|
|
// add eight to account for name + zero end-of-string and the
|
|
// possibility of adding 7 padding bytes
|
|
long len = strlen(parm->attr_name()) + 8;
|
|
ser_write_buf.check_buffer(len);
|
|
ser_write_buf.set_string(parm->attr_name());
|
|
switch (parm->attr_type()) {
|
|
case 'r':
|
|
ser_write_buf.check_buffer(8);
|
|
ser_write_buf.set_double(parm->r);
|
|
break;
|
|
case 's':
|
|
ser_write_buf.check_buffer(strlen(parm->s) + 1);
|
|
ser_write_buf.set_string(parm->s);
|
|
break;
|
|
case 'i':
|
|
ser_write_buf.check_buffer(4);
|
|
ser_write_buf.set_int32(parm->i);
|
|
break;
|
|
case 'l':
|
|
ser_write_buf.check_buffer(4);
|
|
ser_write_buf.set_int32(parm->l);
|
|
break;
|
|
case 'a':
|
|
ser_write_buf.check_buffer(strlen(parm->a) + 1);
|
|
ser_write_buf.set_string(parm->a);
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
Alg_track *Alg_track::unserialize(void *buffer, long len)
|
|
{
|
|
assert(len > 8);
|
|
// should match serialized checksum (just for sanity checks):
|
|
ALGDBG(int chksum = 0; unsigned char *data = (unsigned char *) buffer);
|
|
ALGDBG(for (int i = 0; i < len; i++) chksum += data[i]);
|
|
ALGDBG(printf("Alg_track::unserialize %ld bytes, chksum %d\n",
|
|
len, chksum));
|
|
ser_read_buf.init_for_read(buffer, len);
|
|
bool alg = ser_read_buf.get_char() == 'A' &&
|
|
ser_read_buf.get_char() == 'L' &&
|
|
ser_read_buf.get_char() == 'G';
|
|
assert(alg);
|
|
char c = ser_read_buf.get_char();
|
|
if (c == 'S') {
|
|
Alg_seq *seq = new Alg_seq;
|
|
ser_read_buf.unget_chars(4); // undo get_char() of A,L,G,S
|
|
seq->unserialize_seq();
|
|
return seq;
|
|
} else {
|
|
assert(c == 'T');
|
|
Alg_track *track = new Alg_track;
|
|
ser_read_buf.unget_chars(4); // undo get_char() of A,L,G,T
|
|
track->unserialize_track();
|
|
return track;
|
|
}
|
|
}
|
|
|
|
|
|
#pragma warning(disable: 4800) // long to bool performance warning
|
|
|
|
/* Note: this Alg_seq must have a default initialized Alg_time_map.
|
|
* It will be filled in with data from the ser_read_buf buffer.
|
|
*/
|
|
void Alg_seq::unserialize_seq()
|
|
{
|
|
ser_read_buf.check_input_buffer(48);
|
|
bool algs = (ser_read_buf.get_char() == 'A') &&
|
|
(ser_read_buf.get_char() == 'L') &&
|
|
(ser_read_buf.get_char() == 'G') &&
|
|
(ser_read_buf.get_char() == 'S');
|
|
assert(algs);
|
|
long len = ser_read_buf.get_int32();
|
|
assert(ser_read_buf.get_len() >= len);
|
|
channel_offset_per_track = ser_read_buf.get_int32();
|
|
units_are_seconds = ser_read_buf.get_int32() != 0;
|
|
beat_dur = ser_read_buf.get_double();
|
|
real_dur = ser_read_buf.get_double();
|
|
// no need to allocate an Alg_time_map since it's done during initialization
|
|
time_map->last_tempo = ser_read_buf.get_double();
|
|
time_map->last_tempo_flag = ser_read_buf.get_int32() != 0;
|
|
long beats = ser_read_buf.get_int32();
|
|
ser_read_buf.check_input_buffer(beats * 16 + 4);
|
|
int i;
|
|
for (i = 0; i < beats; i++) {
|
|
double time = ser_read_buf.get_double();
|
|
double beat = ser_read_buf.get_double();
|
|
time_map->insert_beat(time, beat);
|
|
// printf("time_map: %g, %g\n", time, beat);
|
|
}
|
|
long time_sig_len = ser_read_buf.get_int32();
|
|
ser_read_buf.get_pad();
|
|
ser_read_buf.check_input_buffer(time_sig_len * 24 + 8);
|
|
for (i = 0; i < time_sig_len; i++) {
|
|
double beat = ser_read_buf.get_double();
|
|
double num = ser_read_buf.get_double();
|
|
double den = ser_read_buf.get_double();
|
|
time_sig.insert(beat, num, den);
|
|
}
|
|
long tracks_num = ser_read_buf.get_int32();
|
|
ser_read_buf.get_pad();
|
|
add_track(tracks_num - 1); // create tracks_num tracks
|
|
for (i = 0; i < tracks_num; i++) {
|
|
track(i)->unserialize_track();
|
|
}
|
|
// assume seq started at beginning of buffer. len measures
|
|
// bytes after 'ALGS' header, so add 4 bytes and compare to
|
|
// current buffer position -- they should agree
|
|
assert(ser_read_buf.get_posn() == len + 4);
|
|
}
|
|
|
|
|
|
void Alg_track::unserialize_track()
|
|
{
|
|
ser_read_buf.check_input_buffer(32);
|
|
bool algt = (ser_read_buf.get_char() == 'A') &&
|
|
(ser_read_buf.get_char() == 'L') &&
|
|
(ser_read_buf.get_char() == 'G') &&
|
|
(ser_read_buf.get_char() == 'T');
|
|
assert(algt);
|
|
long offset = ser_read_buf.get_posn(); // length does not include 'ALGT'
|
|
long bytes = ser_read_buf.get_int32();
|
|
assert(bytes <= ser_read_buf.get_len() - offset);
|
|
units_are_seconds = (bool) ser_read_buf.get_int32();
|
|
beat_dur = ser_read_buf.get_double();
|
|
real_dur = ser_read_buf.get_double();
|
|
int event_count = ser_read_buf.get_int32();
|
|
for (int i = 0; i < event_count; i++) {
|
|
ser_read_buf.check_input_buffer(24);
|
|
long selected = ser_read_buf.get_int32();
|
|
char type = (char) ser_read_buf.get_int32();
|
|
int32_t key = ser_read_buf.get_int32();
|
|
long channel = ser_read_buf.get_int32();
|
|
double time = ser_read_buf.get_double();
|
|
if (type == 'n') {
|
|
ser_read_buf.check_input_buffer(20);
|
|
float pitch = ser_read_buf.get_float();
|
|
float loud = ser_read_buf.get_float();
|
|
double dur = ser_read_buf.get_double();
|
|
Alg_note *note =
|
|
create_note(time, channel, key, pitch, loud, dur);
|
|
note->set_selected(selected != 0);
|
|
long parm_num = ser_read_buf.get_int32();
|
|
int j;
|
|
// this builds a list of parameters in the correct order
|
|
// (although order shouldn't matter)
|
|
Alg_parameters_ptr *list = ¬e->parameters;
|
|
for (j = 0; j < parm_num; j++) {
|
|
*list = new Alg_parameters(NULL);
|
|
unserialize_parameter(&((*list)->parm));
|
|
list = &((*list)->next);
|
|
}
|
|
append(note);
|
|
} else {
|
|
assert(type == 'u');
|
|
Alg_update *update = create_update(time, channel, key);
|
|
update->set_selected(selected != 0);
|
|
unserialize_parameter(&(update->parameter));
|
|
append(update);
|
|
}
|
|
ser_read_buf.get_pad();
|
|
}
|
|
assert(offset + bytes == ser_read_buf.get_posn());
|
|
}
|
|
|
|
|
|
void Alg_track::unserialize_parameter(Alg_parameter_ptr parm_ptr)
|
|
{
|
|
Alg_attribute attr = ser_read_buf.get_string();
|
|
parm_ptr->attr = symbol_table.insert_string(attr);
|
|
switch (parm_ptr->attr_type()) {
|
|
case 'r':
|
|
ser_read_buf.check_input_buffer(8);
|
|
parm_ptr->r = ser_read_buf.get_double();
|
|
break;
|
|
case 's':
|
|
parm_ptr->s = heapify(ser_read_buf.get_string());
|
|
break;
|
|
case 'i':
|
|
ser_read_buf.check_input_buffer(4);
|
|
parm_ptr->i = ser_read_buf.get_int32();
|
|
break;
|
|
case 'l':
|
|
ser_read_buf.check_input_buffer(4);
|
|
parm_ptr->l = ser_read_buf.get_int32() != 0;
|
|
break;
|
|
case 'a':
|
|
parm_ptr->a = symbol_table.insert_attribute(ser_read_buf.get_string());
|
|
break;
|
|
}
|
|
}
|
|
|
|
#pragma warning(default: 4800)
|
|
|
|
void Alg_track::set_time_map(Alg_time_map *map)
|
|
{
|
|
if (time_map) time_map->dereference();
|
|
if (map == NULL) {
|
|
time_map = new Alg_time_map(); // new default map
|
|
time_map->reference();
|
|
} else {
|
|
time_map = map;
|
|
time_map->reference();
|
|
}
|
|
}
|
|
|
|
|
|
void Alg_track::convert_to_beats()
|
|
// modify all times and durations in notes to beats
|
|
{
|
|
if (units_are_seconds) {
|
|
units_are_seconds = false;
|
|
long i;
|
|
|
|
for (i = 0; i < length(); i++) {
|
|
Alg_event_ptr e = events[i];
|
|
double beat = time_map->time_to_beat(e->time);
|
|
if (e->is_note()) {
|
|
Alg_note_ptr n = (Alg_note_ptr) e;
|
|
n->dur = time_map->time_to_beat(n->time + n->dur) - beat;
|
|
}
|
|
e->time = beat;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void Alg_track::convert_to_seconds()
|
|
// modify all times and durations in notes to seconds
|
|
{
|
|
if (!units_are_seconds) {
|
|
last_note_off = time_map->beat_to_time(last_note_off);
|
|
units_are_seconds = true;
|
|
long i;
|
|
for (i = 0; i < length(); i++) {
|
|
Alg_event_ptr e = events[i];
|
|
double time = time_map->beat_to_time(e->time);
|
|
if (e->is_note()) {
|
|
Alg_note_ptr n = (Alg_note_ptr) e;
|
|
n->dur = time_map->beat_to_time(n->time + n->dur) - time;
|
|
}
|
|
e->time = time;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void Alg_track::set_dur(double duration)
|
|
{
|
|
// set beat_dur and real_dur
|
|
if (units_are_seconds) {
|
|
set_real_dur(duration);
|
|
set_beat_dur(time_map->time_to_beat(duration));
|
|
} else {
|
|
set_beat_dur(duration);
|
|
set_real_dur(time_map->beat_to_time(duration));
|
|
}
|
|
}
|
|
|
|
|
|
Alg_note *Alg_track::create_note(double time, int channel, int identifier,
|
|
float pitch, float loudness, double duration)
|
|
{
|
|
Alg_note *note = new Alg_note();
|
|
note->time = time;
|
|
note->chan = channel;
|
|
note->set_identifier(identifier);
|
|
note->pitch = pitch;
|
|
note->loud = loudness;
|
|
note->dur = duration;
|
|
return note;
|
|
}
|
|
|
|
|
|
Alg_update *Alg_track::create_update(double time, int channel, int identifier)
|
|
{
|
|
Alg_update *update = new Alg_update();
|
|
update->time = time;
|
|
update->chan = channel;
|
|
update->set_identifier(identifier);
|
|
return update;
|
|
}
|
|
|
|
|
|
Alg_track_ptr Alg_track::cut(double t, double len, bool all)
|
|
{
|
|
// since we are translating notes in time, do not copy or use old timemap
|
|
Alg_track_ptr track = new Alg_track();
|
|
track->units_are_seconds = units_are_seconds;
|
|
if (units_are_seconds) {
|
|
track->set_real_dur(len);
|
|
track->set_beat_dur(time_map->time_to_beat(t + len) -
|
|
time_map->time_to_beat(t));
|
|
} else {
|
|
track->set_beat_dur(len);
|
|
track->set_real_dur(time_map->beat_to_time(t + len) -
|
|
time_map->beat_to_time(t));
|
|
}
|
|
int i;
|
|
int new_len = 0;
|
|
int change = 0;
|
|
for (i = 0; i < length(); i++) {
|
|
Alg_event_ptr event = events[i];
|
|
if (event->overlap(t, len, all)) {
|
|
event->time -= t;
|
|
track->append(event);
|
|
change = 1;
|
|
} else { // if we're not cutting this event, move it to
|
|
// eliminate the gaps in events left by cut events
|
|
events[new_len] = event;
|
|
// adjust times of events after t + len
|
|
if (event->time > t + len - ALG_EPS) {
|
|
event->time -= len;
|
|
change = 1;
|
|
}
|
|
new_len++;
|
|
}
|
|
}
|
|
// Alg_event_lists based on this track become invalid
|
|
sequence_number += change;
|
|
this->len = new_len; // adjust length since we removed events
|
|
return track;
|
|
}
|
|
|
|
|
|
Alg_track_ptr Alg_track::copy(double t, double len, bool all)
|
|
{
|
|
// since we are translating notes in time, do not copy or use old timemap
|
|
Alg_track_ptr track = new Alg_track();
|
|
track->units_are_seconds = units_are_seconds;
|
|
if (units_are_seconds) {
|
|
track->set_real_dur(len);
|
|
track->set_beat_dur(time_map->time_to_beat(t + len) -
|
|
time_map->time_to_beat(t));
|
|
} else {
|
|
track->set_beat_dur(len);
|
|
track->set_real_dur(time_map->beat_to_time(t + len) -
|
|
time_map->beat_to_time(t));
|
|
}
|
|
int i;
|
|
for (i = 0; i < length(); i++) {
|
|
Alg_event_ptr event = events[i];
|
|
if (event->overlap(t, len, all)) {
|
|
Alg_event_ptr new_event = copy_event(event);
|
|
new_event->time -= t;
|
|
track->append(new_event);
|
|
}
|
|
}
|
|
return track;
|
|
}
|
|
|
|
|
|
void Alg_track::paste(double t, Alg_event_list *seq)
|
|
{
|
|
assert(get_type() == 't');
|
|
// seq can be an Alg_event_list, an Alg_track, or an Alg_seq
|
|
// if it is an Alg_event_list, units_are_seconds must match
|
|
bool prev_units_are_seconds;
|
|
if (seq->get_type() == 'e') {
|
|
assert(seq->get_owner()->get_units_are_seconds() == units_are_seconds);
|
|
} else { // make it match
|
|
Alg_track_ptr tr = (Alg_track_ptr) seq;
|
|
prev_units_are_seconds = tr->get_units_are_seconds();
|
|
if (units_are_seconds) tr->convert_to_seconds();
|
|
else tr->convert_to_beats();
|
|
}
|
|
double dur = (units_are_seconds ? seq->get_real_dur() :
|
|
seq->get_beat_dur());
|
|
|
|
// Note: in the worst case, seq may contain notes
|
|
// that start almost anytime up to it's duration,
|
|
// so the simplest algorithm is simply a sequence
|
|
// of inserts. If this turns out to be too slow,
|
|
// we can do a merge sort in the case that seq
|
|
// is an Alg_track (if it's an Alg_event_list, we
|
|
// are not guaranteed that the events are in time
|
|
// order, but currently, only a true seq is allowed)
|
|
|
|
int i;
|
|
for (i = 0; i < length(); i++) {
|
|
if (events[i]->time > t - ALG_EPS) {
|
|
events[i]->time += dur;
|
|
}
|
|
}
|
|
for (i = 0; i < seq->length(); i++) {
|
|
Alg_event *new_event = copy_event((*seq)[i]);
|
|
new_event->time += t;
|
|
insert(new_event);
|
|
}
|
|
// restore track units to what they were before
|
|
if (seq->get_type() != 'e') {
|
|
Alg_track_ptr tr = (Alg_track_ptr) seq;
|
|
if (prev_units_are_seconds) tr->convert_to_seconds();
|
|
else tr->convert_to_beats();
|
|
}
|
|
|
|
}
|
|
|
|
|
|
void Alg_track::merge(double t, Alg_event_list_ptr seq)
|
|
{
|
|
Alg_event_list_ref s = *seq;
|
|
for (int i = 0; i < s.length(); i++) {
|
|
Alg_event *new_event;
|
|
if (s[i]->is_note()) {
|
|
new_event = new Alg_note((Alg_note_ptr) s[i]);
|
|
} else {
|
|
new_event = new Alg_update((Alg_update_ptr) s[i]);
|
|
}
|
|
new_event->time += t;
|
|
insert(new_event);
|
|
}
|
|
}
|
|
|
|
|
|
void Alg_track::clear(double t, double len, bool all)
|
|
{
|
|
int i;
|
|
int move_to = 0;
|
|
for (i = 0; i < length(); i++) {
|
|
Alg_event_ptr event = events[i];
|
|
if (event->overlap(t, len, all)) {
|
|
delete events[i];
|
|
} else { // if we're not clearing this event, move it to
|
|
// eliminate the gaps in events left by cleared events
|
|
events[move_to] = event;
|
|
// adjust times of events after t + len. This test is based
|
|
// on the one in Alg_event::overlap() for consistency.
|
|
if (event->time > t + len - ALG_EPS && event->time > t)
|
|
event->time -= len;
|
|
move_to++;
|
|
}
|
|
}
|
|
if (move_to != this->len) { // we cleared at least one note
|
|
sequence_number++; // Alg_event_lists based on this track become invalid
|
|
}
|
|
this->len = move_to; // adjust length since we removed events
|
|
}
|
|
|
|
|
|
void Alg_track::silence(double t, double len, bool all)
|
|
{
|
|
int i;
|
|
int move_to = 0;
|
|
for (i = 0; i < length(); i++) {
|
|
Alg_event_ptr event = events[i];
|
|
if (event->overlap(t, len, all)) {
|
|
delete events[i];
|
|
} else { // if we're not clearing this event, move it to
|
|
// eliminate the gaps in events left by cleared events
|
|
events[move_to] = event;
|
|
move_to++;
|
|
}
|
|
}
|
|
if (move_to != this->len) { // we cleared at least one note
|
|
sequence_number++; // Alg_event_lists based on this track become invalid
|
|
}
|
|
this->len = move_to; // adjust length since we removed events
|
|
}
|
|
|
|
|
|
void Alg_track::insert_silence(double t, double len)
|
|
{
|
|
int i;
|
|
for (i = 0; i < length(); i++) {
|
|
Alg_event_ptr event = events[i];
|
|
if (event->time > t - ALG_EPS) event->time += len;
|
|
}
|
|
}
|
|
|
|
|
|
Alg_event_list *Alg_track::find(double t, double len, bool all,
|
|
int32_t channel_mask, int32_t event_type_mask)
|
|
{
|
|
int i;
|
|
Alg_event_list *list = new Alg_event_list(this);
|
|
if (units_are_seconds) { // t and len are seconds
|
|
list->set_real_dur(len);
|
|
list->set_beat_dur(get_time_map()->time_to_beat(t + len) -
|
|
get_time_map()->time_to_beat(t));
|
|
} else { // t and len are beats
|
|
list->set_real_dur(get_time_map()->beat_to_time(t + len) -
|
|
get_time_map()->beat_to_time(t));
|
|
list->set_beat_dur(len);
|
|
}
|
|
for (i = 0; i < length(); i++) {
|
|
Alg_event_ptr event = events[i];
|
|
if (event->overlap(t, len, all)) {
|
|
if ((channel_mask == 0 ||
|
|
(event->chan < 32 &&
|
|
(channel_mask & (1 << event->chan)))) &&
|
|
((event_type_mask == 0 ||
|
|
(event_type_mask & (1 << event->get_type_code()))))) {
|
|
list->append(event);
|
|
}
|
|
}
|
|
}
|
|
return list;
|
|
}
|
|
|
|
|
|
void Alg_time_sigs::expand()
|
|
{
|
|
assert(maxlen >= len);
|
|
maxlen = (maxlen + 5); // extra growth for small sizes
|
|
maxlen += (maxlen >> 2); // add 25%
|
|
Alg_time_sig_ptr new_time_sigs = new Alg_time_sig[maxlen];
|
|
// now do copy
|
|
memcpy(new_time_sigs, time_sigs, len * sizeof(Alg_time_sig));
|
|
if (time_sigs)
|
|
delete[] time_sigs;
|
|
time_sigs = new_time_sigs;
|
|
}
|
|
|
|
|
|
void Alg_time_sigs::insert(double beat, double num, double den, bool force)
|
|
{
|
|
// find insertion point:
|
|
for (int i = 0; i < len; i++) {
|
|
if (within(time_sigs[i].beat, beat, ALG_EPS)) {
|
|
// overwrite location i with new info
|
|
time_sigs[i].beat = beat;
|
|
time_sigs[i].num = num;
|
|
time_sigs[i].den = den;
|
|
return;
|
|
} else if (time_sigs[i].beat > beat) {
|
|
if ((i > 0 && // check if redundant with prev. time sig
|
|
time_sigs[i - 1].num == num &&
|
|
time_sigs[i - 1].den == den &&
|
|
within(fmod(beat - time_sigs[i - 1].beat,
|
|
4 * time_sigs[i-1].num / time_sigs[i-1].den),
|
|
0, ALG_EPS)) ||
|
|
// check if redundant with implied initial 4/4 time sig:
|
|
(i == 0 && num == 4 && den == 4 &&
|
|
within(fmod(beat, 4), 0, ALG_EPS))) {
|
|
if (!force) return; // redundant inserts can be ignored here
|
|
}
|
|
// make room for new event
|
|
if (maxlen <= len) expand();
|
|
// insert new event at i
|
|
memmove(&time_sigs[i + 1], &time_sigs[i],
|
|
sizeof(Alg_time_sig) * (len - i));
|
|
time_sigs[i].beat = beat;
|
|
time_sigs[i].num = num;
|
|
time_sigs[i].den = den;
|
|
len++;
|
|
return;
|
|
}
|
|
}
|
|
// if we fall out of loop, then this goes at end
|
|
if (maxlen <= len) expand();
|
|
time_sigs[len].beat = beat;
|
|
time_sigs[len].num = num;
|
|
time_sigs[len].den = den;
|
|
len++;
|
|
}
|
|
|
|
|
|
void Alg_time_sigs::show()
|
|
{
|
|
printf("Alg_time_sig: ");
|
|
for (int i = 0; i < len; i++) {
|
|
printf("(%g: %g/%g) ", time_sigs[i].beat, time_sigs[i].num, time_sigs[i].den);
|
|
}
|
|
printf("\n");
|
|
}
|
|
|
|
|
|
int Alg_time_sigs::find_beat(double beat)
|
|
{
|
|
// index where you would insert a new time signature at beat
|
|
int i = 0;
|
|
while (i < len && time_sigs[i].beat < beat - ALG_EPS) i++;
|
|
return i;
|
|
}
|
|
|
|
|
|
double Alg_time_sigs::get_bar_len(double beat)
|
|
{
|
|
int i = find_beat(beat);
|
|
double num = 4.0;
|
|
double den = 4.0;
|
|
if (i != 0) {
|
|
num = time_sigs[i - 1].num;
|
|
den = time_sigs[i - 1].den;
|
|
}
|
|
return 4 * num / den;
|
|
}
|
|
|
|
void Alg_time_sigs::cut(double start, double end, double dur)
|
|
{
|
|
// remove time_sig's from start to end -- these must be
|
|
// in beats (not seconds).
|
|
// The duration of the whole sequence is dur (beats).
|
|
|
|
// If the first bar line after end comes before a time signature
|
|
// and does not fall on a bar line, insert a time signature at
|
|
// the time of the bar line to retain relative bar line positions
|
|
|
|
int i = find_beat(end);
|
|
// i is where you would insert a new time sig at beat,
|
|
// Case 1: beat coincides with a time sig at i. Time signature
|
|
// at beat means that there is a barline at beat, so when beat
|
|
// is shifted to start, the relative barline positions are preserved
|
|
if (len > 0 &&
|
|
within(end, time_sigs[i].beat, ALG_EPS)) {
|
|
// beat coincides with time signature change, so end is on a barline
|
|
/* do nothing */ ;
|
|
// Case 2: there is no time signature before end
|
|
} else if (i == 0 && (len == 0 ||
|
|
time_sigs[0].beat > end)) {
|
|
// If the next time signature does not fall on a barline,
|
|
// then end must not be on a barline, so there is a partial
|
|
// measure from end to the next barline. We need
|
|
// a time signature there to preserve relative barline
|
|
// locations. It may be that the next bar after start is
|
|
// due to another time signature, in which case we do not
|
|
// need to insert anything.
|
|
double measures = end / 4.0;
|
|
double imeasures = ROUND(measures);
|
|
if (!within(measures, imeasures, ALG_EPS)) {
|
|
// start is not on a barline, maybe add one here:
|
|
double bar_loc = (int(measures) + 1) * 4.0;
|
|
if (bar_loc < dur - ALG_EPS &&
|
|
(len == 0 || time_sigs[0].beat > bar_loc + ALG_EPS)) {
|
|
insert(bar_loc, 4, 4, true); // forced insert
|
|
}
|
|
}
|
|
// This case should never be true because if i == 0, either there
|
|
// are no time signatures before beat (Case 2),
|
|
// or there is one time signature at beat (Case 1)
|
|
} else if (i == 0) {
|
|
/* do nothing (might be good to assert(false)) */ ;
|
|
// Case 3: i-1 must be the effective time sig position
|
|
} else {
|
|
// get the time signature in effect at end
|
|
Alg_time_sig &tsp = time_sigs[i - 1];
|
|
double beats_per_measure = (tsp.num * 4) / tsp.den;
|
|
double measures = (end - tsp.beat) / beats_per_measure;
|
|
int imeasures = ROUND(measures);
|
|
if (!within(measures, imeasures, ALG_EPS)) {
|
|
// end is not on a measure, so we need to insert a time sig
|
|
// to force a bar line at the first measure location after
|
|
// beat, if any
|
|
double bar_loc = tsp.beat + beats_per_measure * (int(measures) + 1);
|
|
// insert new time signature at bar_loc
|
|
// It will have the same time signature, but the position will
|
|
// force a barline to match the barline before the shift
|
|
// However, we should not insert a barline if there is a
|
|
// time signature earlier than the barline time
|
|
if (i < len /* time_sigs[i] is the last one */ &&
|
|
time_sigs[i].beat < bar_loc - ALG_EPS) {
|
|
/* do not insert because there's already a time signature */;
|
|
} else if (bar_loc < dur - ALG_EPS) {
|
|
insert(bar_loc, tsp.num, tsp.den, true); // forced insert
|
|
}
|
|
}
|
|
// else beat coincides with a barline, so no need for an extra
|
|
// time signature to force barline alignment
|
|
}
|
|
|
|
// Figure out if time signature at start matches
|
|
// the time signature at end. If not, we need to insert a
|
|
// time signature at end to force the correct time signature
|
|
// there.
|
|
// Find time signature at start:
|
|
double start_num = 4.0; // default if no time signature specified
|
|
double start_den = 4.0;
|
|
i = find_beat(start);
|
|
// A time signature at start would go at index i, so the effective
|
|
// time signature prior to start is at i - 1. If i == 0, the default
|
|
// time signature is in effect prior to start.
|
|
if (i != 0) {
|
|
start_num = time_sigs[i - 1].num;
|
|
start_den = time_sigs[i - 1].den;
|
|
}
|
|
// Find the time signature at end:
|
|
double end_num = 4.0; // default if no time signature specified
|
|
double end_den = 4.0;
|
|
int j = find_beat(end);
|
|
if (j != 0) {
|
|
end_num = time_sigs[j - 1].num;
|
|
end_den = time_sigs[j - 1].den;
|
|
}
|
|
// compare: If meter changes and there is no time signature at end,
|
|
// insert a time signature at end
|
|
if (end < dur - ALG_EPS &&
|
|
(start_num != end_num || start_den != end_den) &&
|
|
(j >= len || !within(time_sigs[j].beat, end, ALG_EPS))) {
|
|
insert(end, end_num, end_den, true);
|
|
}
|
|
|
|
// Remove time signatures from start to end (not including one AT
|
|
// end, if there is one there. Be careful with ALG_EPS on that one.)
|
|
|
|
// since we may have inserted a time signature, find position again:
|
|
int i0 = find_beat(start);
|
|
int i1 = i0;
|
|
// scan to end of cut region
|
|
while (i1 < len && time_sigs[i1].beat < end - ALG_EPS) {
|
|
i1++;
|
|
}
|
|
// scan from end to len(time_sig)
|
|
while (i1 < len) {
|
|
Alg_time_sig &ts = time_sigs[i1];
|
|
ts.beat -= (end - start);
|
|
time_sigs[i0] = ts;
|
|
i0++;
|
|
i1++;
|
|
}
|
|
len = i1;
|
|
}
|
|
|
|
|
|
void Alg_time_sigs::trim(double start, double end)
|
|
{
|
|
// remove time_sig's not in [start, end), but retain
|
|
// barline positions relative to the notes. This means that
|
|
// if the meter (time signature) changes between start and
|
|
// end that we need to insert a time signature at start.
|
|
// Also, if trim() would cause barlines to move, we need to
|
|
// insert a time signature on a barline (timesignatures
|
|
// imply the beginning of a bar even if the previous bar
|
|
// does not have enough beats. Note that bars do not need
|
|
// to have an integer number of beats).
|
|
//
|
|
// units must be in beats (not seconds)
|
|
//
|
|
// Uses Alg_time_sigs::cut() to avoid writing a special case
|
|
double dur = end + 1000;
|
|
if (len > 0) {
|
|
dur = time_sigs[len - 1].beat + 1000;
|
|
}
|
|
cut(end, dur, dur);
|
|
cut(0, start, dur);
|
|
|
|
#ifdef IGNORE_THIS_OLD_CODE
|
|
// first, skip time signatures up to start
|
|
int i = find_beat(start);
|
|
// i is where you would insert a new time sig at beat,
|
|
// Case 1: beat coincides with a time sig at i. Time signature
|
|
// at beat means that there is a barline at beat, so when beat
|
|
// is shifted to 0, the relative barline positions are preserved
|
|
if (len > 0 &&
|
|
within(start, time_sigs[i].beat, ALG_EPS)) {
|
|
// beat coincides with time signature change, so offset must
|
|
// be a multiple of beats
|
|
/* do nothing */ ;
|
|
// Case 2: there is no time signature before start
|
|
} else if (i == 0 && (len == 0 ||
|
|
time_sigs[0].beat > start)) {
|
|
// If the next time signature does not fall on a barline,
|
|
// then start must not be on a barline, so there is a partial
|
|
// measure from start to the next barline. We need
|
|
// a time signature there to preserve relative barline
|
|
// locations. It may be that the next bar after start is
|
|
// due to another time signature, in which case we do not
|
|
// need to insert anything.
|
|
double measures = start / 4.0;
|
|
double imeasures = ROUND(measures);
|
|
if (!within(measures, imeasures, ALG_EPS)) {
|
|
// start is not on a barline, maybe add one here:
|
|
double bar_loc = (int(measures) + 1) * 4.0;
|
|
if (len == 0 || time_sigs[1].beat > bar_loc + ALG_EPS) {
|
|
insert(bar_loc, 4, 4, true);
|
|
}
|
|
}
|
|
// This case should never be true because if i == 0, either there
|
|
// are no time signatures before beat (Case 2),
|
|
// or there is one time signature at beat (Case 1)
|
|
} else if (i == 0) {
|
|
/* do nothing (might be good to assert(false)) */ ;
|
|
// Case 3: i-1 must be the effective time sig position
|
|
} else {
|
|
i -= 1; // index the time signature in effect at start
|
|
Alg_time_sig &tsp = time_sigs[i];
|
|
double beats_per_measure = (tsp.num * 4) / tsp.den;
|
|
double measures = (start - tsp.beat) / beats_per_measure;
|
|
int imeasures = ROUND(measures);
|
|
if (!within(measures, imeasures, ALG_EPS)) {
|
|
// beat is not on a measure, so we need to insert a time sig
|
|
// to force a bar line at the first measure location after
|
|
// beat, if any
|
|
double bar_loc = tsp.beat + beats_per_measure * (int(measures) + 1);
|
|
// insert new time signature at bar_loc
|
|
// It will have the same time signature, but the position will
|
|
// force a barline to match the barline before the shift
|
|
insert(bar_loc, tsp.num, tsp.den, true);
|
|
}
|
|
// else beat coincides with a barline, so no need for an extra
|
|
// time signature to force barline alignment
|
|
}
|
|
// since we may have inserted a time signature, find position again:
|
|
int i_in = find_beat(start);
|
|
int i_out = 0;
|
|
|
|
// put time_sig at start if necessary
|
|
// if 0 < i_in < len, then the time sig at i_in is either
|
|
// at start or after start.
|
|
// If after start, then insert time sig at i_in-1 at 0.
|
|
// Otherwise, we'll pick up time sig at i_in below.
|
|
// If 0 == i_in < len, then the time sig at i_in is either
|
|
// at start or after start.
|
|
// If after start, then time sig at 0 is 4/4, but that's the
|
|
// default, so do nothing.
|
|
// Otherwise, we'll pick up time sig at i_in below.
|
|
// If 0 < i_in == len, then insert time_sig at i_in-1 at start
|
|
// If 0 == i_in == len, then 4/4 default applies and we're done.
|
|
//
|
|
// So the conditions for inserting time_sig[in_i-1] at 0 are:
|
|
// (0 < i_in < len and time_sig[i] > start+ALG_EPS) OR
|
|
// (0 < i_in == len)
|
|
// We can rewrite this to
|
|
// (0 < i_in) && ((i_in < len && time_sig[i_in].beat > start + ALG_EPS) ||
|
|
// (i_in == len)))
|
|
//
|
|
if (0 < i_in && ((i_in < len && time_sigs[i_in].beat > start + ALG_EPS) ||
|
|
(i_in == len))) {
|
|
time_sigs[0] = time_sigs[i_in - 1];
|
|
time_sigs[0].beat = 0.0;
|
|
i_out = 1;
|
|
}
|
|
// copy from i_in to i_out as we scan time_sig array to end of cut region
|
|
while (i_in < len && time_sigs[i_in].beat < end - ALG_EPS) {
|
|
Alg_time_sig &ts = time_sigs[i_in];
|
|
ts.beat = ts.beat - start;
|
|
time_sigs[i_out] = ts;
|
|
i_in++;
|
|
i_out++;
|
|
}
|
|
len = i_out;
|
|
#endif
|
|
}
|
|
|
|
|
|
void Alg_time_sigs::paste(double start, Alg_seq *seq)
|
|
{
|
|
// printf("time_sig::insert before paste\n");
|
|
// show();
|
|
Alg_time_sigs &from = seq->time_sig;
|
|
// printf("time_sig::insert from\n");
|
|
// from.show();
|
|
// insert time signatures from seq into this time_sigs at start
|
|
if (len == 0 && from.len == 0) {
|
|
return; // default applies
|
|
}
|
|
int i = find_beat(start);
|
|
// remember the time signature at the splice point
|
|
double num_after_splice = 4;
|
|
double den_after_splice = 4; // default
|
|
double num_before_splice = 4;
|
|
double den_before_splice = 4; // default
|
|
// this is computed for use in aligning beats after the inserted
|
|
// time signatures and duration. It is the position of time signature
|
|
// in effect immediately after start (the time signature will be
|
|
// before start or at start)
|
|
double beat_after_splice = 0.0;
|
|
// three cases:
|
|
// 1) time sig at splice is at i-1
|
|
// for this, we must have len>0 & i>0
|
|
// two sub-cases:
|
|
// A) i < len && time_sig[i].beat > start
|
|
// B) i == len
|
|
// 2) time_sig at splice is at i
|
|
// for this, i < len && time_sig[i].beat ~= start
|
|
// 3) time_sig at splice is default 4/4
|
|
if (len > 0 && i > 0 &&
|
|
((i < len && time_sigs[i].beat > start + ALG_EPS) ||
|
|
(i == len))) {
|
|
// no time_signature at i
|
|
num_after_splice = time_sigs[i-1].num;
|
|
den_after_splice = time_sigs[i-1].den;
|
|
beat_after_splice = time_sigs[i - 1].beat;
|
|
num_before_splice = num_after_splice;
|
|
den_before_splice = den_after_splice;
|
|
} else if (i < len && time_sigs[i].beat <= start + ALG_EPS) {
|
|
// time_signature at i is at "start" beats
|
|
num_after_splice = time_sigs[i].num;
|
|
den_after_splice = time_sigs[i].den;
|
|
beat_after_splice = start;
|
|
if (i > 0) { // time signature before start is at i - 1
|
|
num_before_splice = time_sigs[i-1].num;
|
|
den_before_splice = time_sigs[i-1].den;
|
|
}
|
|
}
|
|
// i is where insert will go, time_sig[i].beat >= start
|
|
// begin by adding duration to time_sig's at i and above
|
|
// move time signatures forward by duration of seq
|
|
double dur = seq->get_beat_dur();
|
|
while (i < len) {
|
|
time_sigs[i].beat += dur;
|
|
i++;
|
|
}
|
|
//printf("time_sig::insert after making space\n");
|
|
//show();
|
|
// If time signature of "from" is not the effective time signature
|
|
// at start, insert a time_signature at start. This may create
|
|
// an extra measure if seq does not begin on a measure boundary
|
|
double num_of_insert = 4.0;
|
|
double den_of_insert = 4.0;
|
|
double beat_of_insert = 0.0;
|
|
int first_from_index = 0; // where to start copying from
|
|
if (from.length() > 0 && from[0].beat < ALG_EPS) {
|
|
// there is an initial time signature in "from"
|
|
num_of_insert = from[0].num;
|
|
den_of_insert = from[0].den;
|
|
// since we are handling the first time signature in from,
|
|
// we can start copying at index == 1:
|
|
first_from_index = 1;
|
|
}
|
|
// compare time signatures to see if we need a change at start:
|
|
if (num_before_splice != num_of_insert ||
|
|
den_before_splice != den_of_insert) {
|
|
// note that this will overwrite an existing time signature if
|
|
// it is within ALG_EPS of start -- this is correct because the
|
|
// existing time signature will already be recorded as
|
|
// num_after_splice and den_after_splice
|
|
insert(start, num_of_insert, den_of_insert);
|
|
}
|
|
//printf("time_sig::insert after 4/4 at start\n");
|
|
//show();
|
|
// insert time signatures from seq offset by start
|
|
for (i = 0; i < from.length() && from[i].beat < dur - ALG_EPS; i++) {
|
|
num_of_insert = from[i].num; // keep latest time signature info
|
|
den_of_insert = from[i].den;
|
|
beat_of_insert = from[i].beat;
|
|
insert(start + beat_of_insert, num_of_insert, den_of_insert);
|
|
}
|
|
//printf("time_sig::insert after pasting in sigs\n");
|
|
//show();
|
|
// now insert time signature at end of splice if necessary
|
|
// if the time signature changes, we need to insert a time signature
|
|
// immediately:
|
|
if (num_of_insert != num_after_splice &&
|
|
den_of_insert != den_after_splice) {
|
|
insert(start + dur, num_after_splice, den_after_splice);
|
|
num_of_insert = num_after_splice;
|
|
den_of_insert = den_after_splice;
|
|
beat_of_insert = start + dur;
|
|
}
|
|
// if the insert had a partial number of measures, we might need an
|
|
// additional time signature to realign the barlines after the insert
|
|
// To decide, we compare the beat of the first barline on or after
|
|
// start before the splice to the beat of the first barline on or
|
|
// after start + dur after the splice. In a sense, this is the "same"
|
|
// barline, so it should be shifted exactly by dur.
|
|
// First, compute the beat of the first barline on or after start:
|
|
double beats_per_measure = (num_after_splice * 4) / den_after_splice;
|
|
double measures = (start - beat_after_splice) / beats_per_measure;
|
|
// Measures might be slightly negative due to rounding. Use max()
|
|
// to eliminate any negative rounding error:
|
|
int imeasures = int(max(measures, 0.0));
|
|
double old_bar_loc = beat_after_splice + (imeasures * beats_per_measure);
|
|
if (old_bar_loc < start) old_bar_loc += beats_per_measure;
|
|
// now old_bar_loc is the original first bar position after start
|
|
// Do similar calculation for position after end after the insertion:
|
|
// beats_per_measure already calculated because signatures match
|
|
measures = (start + dur - beat_of_insert) / beats_per_measure;
|
|
imeasures = int(max(measures, 0.0));
|
|
double new_bar_loc = beat_of_insert + (imeasures * beats_per_measure);
|
|
if (new_bar_loc < start + dur) new_bar_loc += beats_per_measure;
|
|
// old_bar_loc should be shifted by dur:
|
|
old_bar_loc += dur;
|
|
// now the two bar locations should be equal, but due to rounding,
|
|
// they could be off by one measure
|
|
double diff = (new_bar_loc - old_bar_loc) + beats_per_measure;
|
|
double diff_in_measures = diff / beats_per_measure;
|
|
// if diff_in_measures is not (approximately) integer, we need to
|
|
// force a barline (time signature) after start + dur to maintain
|
|
// the relationship between barliness and notes
|
|
if (!within(diff_in_measures, ROUND(diff_in_measures), ALG_EPS)) {
|
|
// recall that old_bar_loc is shifted by dur
|
|
insert(old_bar_loc, num_after_splice, den_after_splice);
|
|
}
|
|
//printf("time_sig::insert after sig at end of splice\n");
|
|
//show();
|
|
}
|
|
|
|
|
|
void Alg_time_sigs::insert_beats(double start, double dur)
|
|
{
|
|
int i = find_beat(start);
|
|
|
|
// time_sigs[i] is after beat and needs to shift
|
|
// Compute the time of the first bar at or after beat so that
|
|
// a bar can be placed at bar_loc + dur
|
|
double tsnum = 4.0;
|
|
double tsden = 4.0;
|
|
double tsbeat = 0.0; // defaults
|
|
|
|
// three cases:
|
|
// 1) time sig at splice is at i-1
|
|
// for this, we must have len>0 & i>0
|
|
// two sub-cases:
|
|
// A) i < len && time_sig[i].beat > start
|
|
// B) i == len
|
|
// 2) time_sig at splice is at i
|
|
// for this, i < len && time_sig[i].beat ~= start
|
|
// 3) time_sig at splice is default 4/4
|
|
if (len > 0 && i > 0 &&
|
|
((i < len && time_sigs[i].beat > start + ALG_EPS) ||
|
|
(i == len))) {
|
|
// no time_signature at i
|
|
tsnum = time_sigs[i-1].num;
|
|
tsden = time_sigs[i-1].den;
|
|
tsbeat = time_sigs[i-1].beat;
|
|
} else if (i < len && time_sigs[i].beat <= start + ALG_EPS) {
|
|
// time_signature at i is at "start" beats
|
|
tsnum = time_sigs[i].num;
|
|
tsden = time_sigs[i].den;
|
|
tsbeat = start;
|
|
i++; // we want i to be index of next time signature after start
|
|
}
|
|
// invariant: i is index of next time signature after start
|
|
|
|
// increase beat times from i to len - 1 by dur
|
|
for (int j = i; j < len; j++) {
|
|
time_sigs[j].beat += dur;
|
|
}
|
|
|
|
// insert a time signature to maintain bar positions if necessary
|
|
double beats_per_measure = (tsnum * 4) / tsden;
|
|
double measures = dur / beats_per_measure; // shift distance
|
|
int imeasures = ROUND(measures);
|
|
if (!within(measures, imeasures, ALG_EPS)) {
|
|
// shift is not a whole number of measures, so we may need to insert
|
|
// time signature after silence
|
|
// compute measures from time signature to next bar after time
|
|
measures = (start - tsbeat) / beats_per_measure;
|
|
// round up and add to tsbeat to get time of next bar
|
|
double bar_loc = tsbeat + beats_per_measure * (int(measures) + 1);
|
|
// translate bar_loc by len:
|
|
bar_loc += dur; // this is where we want a bar to be, but maybe
|
|
// there is a time signature change before bar, in which case we
|
|
// should not insert a new time signature
|
|
// The next time signature after start is at i if i < len
|
|
if (i < len && time_sigs[i].beat < bar_loc) {
|
|
/* do not insert */;
|
|
} else {
|
|
insert(bar_loc, tsnum, tsden);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
double Alg_time_sigs::nearest_beat(double beat)
|
|
{
|
|
int i = find_beat(beat);
|
|
// i is where we would insert time signature at beat
|
|
// case 1: there is no time signature
|
|
if (i == 0 && len == 0) {
|
|
return ROUND(beat);
|
|
// case 2: beat falls approximately on time signature
|
|
} else if (i < len && within(time_sigs[i].beat, beat, ALG_EPS)) {
|
|
return time_sigs[i].beat;
|
|
// case 3: beat is after no time signature and before one
|
|
} else if (i == 0) {
|
|
double trial_beat = ROUND(beat);
|
|
// it is possible that we rounded up past a time signature
|
|
if (trial_beat > time_sigs[0].beat - ALG_EPS) {
|
|
return time_sigs[0].beat;
|
|
}
|
|
return trial_beat;
|
|
}
|
|
// case 4: beat is after some time signature
|
|
double trial_beat = time_sigs[i - 1].beat +
|
|
ROUND(beat - time_sigs[i - 1].beat);
|
|
// rounding may advance trial_beat past next time signature:
|
|
if (i < len && trial_beat > time_sigs[i].beat - ALG_EPS) {
|
|
return time_sigs[i].beat;
|
|
}
|
|
return trial_beat;
|
|
}
|
|
|
|
|
|
Alg_tracks::~Alg_tracks()
|
|
{
|
|
reset();
|
|
}
|
|
|
|
|
|
void Alg_tracks::expand_to(int new_max)
|
|
{
|
|
maxlen = new_max;
|
|
Alg_track_ptr *new_tracks = new Alg_track_ptr[maxlen];
|
|
// now do copy
|
|
memcpy(new_tracks, tracks, len * sizeof(Alg_track_ptr));
|
|
if (tracks) {
|
|
delete[] tracks;
|
|
}
|
|
tracks = new_tracks;
|
|
}
|
|
|
|
|
|
void Alg_tracks::expand()
|
|
{
|
|
maxlen = (maxlen + 5); // extra growth for small sizes
|
|
maxlen += (maxlen >> 2); // add 25%
|
|
expand_to(maxlen);
|
|
}
|
|
|
|
|
|
void Alg_tracks::append(Alg_track_ptr track)
|
|
{
|
|
if (maxlen <= len) {
|
|
expand();
|
|
}
|
|
tracks[len] = track;
|
|
len++;
|
|
}
|
|
|
|
|
|
void Alg_tracks::add_track(int track_num, Alg_time_map_ptr time_map,
|
|
bool seconds)
|
|
// Create a new track at index track_num.
|
|
// If track already exists, this call does nothing.
|
|
// If highest previous track is not at track_num-1, then
|
|
// create tracks at len, len+1, ..., track_num.
|
|
{
|
|
assert(track_num >= 0);
|
|
if (track_num == maxlen) {
|
|
// use eponential growth to insert tracks sequentially
|
|
expand();
|
|
} else if (track_num > maxlen) {
|
|
// grow to exact size for random inserts
|
|
expand_to(track_num + 1);
|
|
}
|
|
if (track_num < len) return; // don't add if already there
|
|
while (len <= track_num) {
|
|
tracks[len] = new Alg_track(time_map, seconds);
|
|
//printf("allocated track at %d (%x, this %x) = %x\n", len,
|
|
// &(tracks[len]), this, tracks[len]);
|
|
len++;
|
|
}
|
|
}
|
|
|
|
|
|
void Alg_tracks::reset()
|
|
{
|
|
// all track events are incorporated into the seq,
|
|
// so all we need to delete are the arrays of pointers
|
|
for (int i = 0; i < len; i++) {
|
|
// printf("deleting track at %d (%x, this %x) = %x\n", i, &(tracks[i]),
|
|
// this, tracks[i]);
|
|
delete tracks[i];
|
|
}
|
|
if (tracks) delete [] tracks;
|
|
tracks = NULL;
|
|
len = 0;
|
|
maxlen = 0;
|
|
}
|
|
|
|
|
|
void Alg_tracks::set_in_use(bool flag)
|
|
{
|
|
for (int i = 0; i < len; i++) {
|
|
tracks[i]->in_use = flag;
|
|
}
|
|
}
|
|
|
|
|
|
void Alg_iterator::expand_to(int new_max)
|
|
{
|
|
maxlen = new_max;
|
|
Alg_pending_event_ptr new_pending_events = new Alg_pending_event[maxlen];
|
|
// now do copy
|
|
memcpy(new_pending_events, pending_events,
|
|
len * sizeof(Alg_pending_event));
|
|
if (pending_events) {
|
|
delete[] pending_events;
|
|
}
|
|
pending_events = new_pending_events;
|
|
}
|
|
|
|
|
|
void Alg_iterator::expand()
|
|
{
|
|
maxlen = (maxlen + 5); // extra growth for small sizes
|
|
maxlen += (maxlen >> 2); // add 25%
|
|
expand_to(maxlen);
|
|
}
|
|
|
|
|
|
Alg_iterator::~Alg_iterator()
|
|
{
|
|
if (pending_events) {
|
|
delete[] pending_events;
|
|
}
|
|
}
|
|
|
|
|
|
/* in the heap, the children of N are (N+1)*2 and (N+1)*2-1, so
|
|
* the parent of N is (N+1)/2-1. This would be easier if arrays
|
|
* were 1-based instead of 0-based
|
|
*/
|
|
#define HEAP_PARENT(loc) ((((loc) + 1) / 2) - 1)
|
|
#define FIRST_CHILD(loc) (((loc) * 2) + 1)
|
|
|
|
void Alg_iterator::show()
|
|
{
|
|
for (int i = 0; i < len; i++) {
|
|
Alg_pending_event_ptr p = &(pending_events[i]);
|
|
printf(" %d: %p[%ld]@%g on %d\n", i, p->events, p->index,
|
|
p->offset, p->note_on);
|
|
}
|
|
}
|
|
|
|
|
|
bool Alg_iterator::earlier(int i, int j)
|
|
// see if event i is earlier than event j
|
|
{
|
|
// note-offs are scheduled ALG_EPS early so that if a note-off is
|
|
// followed immediately with the same timestamp by a note-on (common
|
|
// in MIDI files), the note-off will be scheduled first
|
|
|
|
double t_i = pending_events[i].time;
|
|
double t_j = pending_events[j].time;
|
|
|
|
if (t_i < t_j) return true;
|
|
// not sure if this case really exists or this is the best rule, but
|
|
// we want to give precedence to note-off events
|
|
else if (t_i == t_j && pending_events[j].note_on) return true;
|
|
return false;
|
|
}
|
|
|
|
|
|
void Alg_iterator::insert(Alg_events_ptr events, long index,
|
|
bool note_on, void *cookie, double offset)
|
|
{
|
|
if (len == maxlen) expand();
|
|
pending_events[len].events = events;
|
|
pending_events[len].index = index;
|
|
pending_events[len].note_on = note_on;
|
|
pending_events[len].cookie = cookie;
|
|
pending_events[len].offset = offset;
|
|
Alg_event_ptr event = (*events)[index];
|
|
pending_events[len].time = (note_on ? event->time :
|
|
event->get_end_time() - ALG_EPS) + offset;
|
|
/* BEGIN DEBUG *
|
|
printf("insert %p=%p[%d] @ %g\n", event, events, index,
|
|
pending_events[len].time);
|
|
printf(" is_note %d note_on %d time %g dur %g end_time %g offset %g\n",
|
|
event->is_note(), note_on, event->time, event->get_duration(),
|
|
event->get_end_time(), offset);
|
|
}
|
|
* END DEBUG */
|
|
int loc = len;
|
|
int loc_parent = HEAP_PARENT(loc);
|
|
len++;
|
|
// sift up:
|
|
while (loc > 0 &&
|
|
earlier(loc, loc_parent)) {
|
|
// swap loc with loc_parent
|
|
Alg_pending_event temp = pending_events[loc];
|
|
pending_events[loc] = pending_events[loc_parent];
|
|
pending_events[loc_parent] = temp;
|
|
loc = loc_parent;
|
|
loc_parent = HEAP_PARENT(loc);
|
|
}
|
|
}
|
|
|
|
|
|
bool Alg_iterator::remove_next(Alg_events_ptr &events, long &index,
|
|
bool ¬e_on, void *&cookie,
|
|
double &offset, double &time)
|
|
{
|
|
if (len == 0) return false; // empty!
|
|
events = pending_events[0].events;
|
|
index = pending_events[0].index;
|
|
note_on = pending_events[0].note_on;
|
|
offset = pending_events[0].offset;
|
|
cookie = pending_events[0].cookie;
|
|
offset = pending_events[0].offset;
|
|
time = pending_events[0].time;
|
|
len--;
|
|
pending_events[0] = pending_events[len];
|
|
// sift down
|
|
long loc = 0;
|
|
long loc_child = FIRST_CHILD(loc);
|
|
while (loc_child < len) {
|
|
if (loc_child + 1 < len) {
|
|
if (earlier(loc_child + 1, loc_child)) {
|
|
loc_child++;
|
|
}
|
|
}
|
|
if (earlier(loc_child, loc)) {
|
|
Alg_pending_event temp = pending_events[loc];
|
|
pending_events[loc] = pending_events[loc_child];
|
|
pending_events[loc_child] = temp;
|
|
loc = loc_child;
|
|
loc_child = FIRST_CHILD(loc);
|
|
} else {
|
|
loc_child = len;
|
|
}
|
|
}
|
|
// printf("After remove:"); show();
|
|
return true;
|
|
}
|
|
|
|
|
|
Alg_seq::Alg_seq(const char *filename, bool smf, double *offset_ptr)
|
|
{
|
|
basic_initialization();
|
|
ifstream inf(filename, smf ? ios::binary | ios::in : ios::in);
|
|
if (inf.fail()) {
|
|
error = alg_error_open;
|
|
return;
|
|
}
|
|
if (smf) {
|
|
error = alg_smf_read(inf, this);
|
|
if (offset_ptr) *offset_ptr = 0.0;
|
|
} else {
|
|
error = alg_read(inf, this, offset_ptr);
|
|
}
|
|
inf.close();
|
|
}
|
|
|
|
|
|
Alg_seq::Alg_seq(istream &file, bool smf, double *offset_ptr)
|
|
{
|
|
basic_initialization();
|
|
if (smf) {
|
|
error = alg_smf_read(file, this);
|
|
if (offset_ptr) *offset_ptr = 0.0;
|
|
} else {
|
|
error = alg_read(file, this, offset_ptr);
|
|
}
|
|
}
|
|
|
|
void Alg_seq::seq_from_track(Alg_track_ref tr)
|
|
{
|
|
type = 's';
|
|
// copy everything
|
|
set_beat_dur(tr.get_beat_dur());
|
|
set_real_dur(tr.get_real_dur());
|
|
// copy time_map
|
|
set_time_map(new Alg_time_map(tr.get_time_map()));
|
|
units_are_seconds = tr.get_units_are_seconds();
|
|
|
|
if (tr.get_type() == 's') {
|
|
Alg_seq_ref s = *(tr.to_alg_seq());
|
|
channel_offset_per_track = s.channel_offset_per_track;
|
|
add_track(s.tracks() - 1);
|
|
// copy each track
|
|
for (int i = 0; i < tracks(); i++) {
|
|
Alg_track_ref from_track = *(s.track(i));
|
|
Alg_track_ref to_track = *(track(i));
|
|
to_track.set_beat_dur(from_track.get_beat_dur());
|
|
to_track.set_real_dur(from_track.get_real_dur());
|
|
if (from_track.get_units_are_seconds())
|
|
to_track.convert_to_seconds();
|
|
for (int j = 0; j < from_track.length(); j++) {
|
|
Alg_event_ptr event = copy_event(from_track[j]);
|
|
to_track.append(event);
|
|
}
|
|
}
|
|
} else if (tr.get_type() == 't') {
|
|
add_track(0);
|
|
channel_offset_per_track = 0;
|
|
Alg_track_ptr to_track = track(0);
|
|
to_track->set_beat_dur(tr.get_beat_dur());
|
|
to_track->set_real_dur(tr.get_real_dur());
|
|
for (int j = 0; j < tr.length(); j++) {
|
|
Alg_event_ptr event = copy_event(tr[j]);
|
|
to_track->append(event);
|
|
}
|
|
} else {
|
|
assert(false); // expected track or sequence
|
|
}
|
|
}
|
|
|
|
|
|
int Alg_seq::tracks()
|
|
{
|
|
return track_list.length();
|
|
}
|
|
|
|
|
|
Alg_track_ptr Alg_seq::track(int i)
|
|
{
|
|
assert(0 <= i && i < track_list.length());
|
|
return &(track_list[i]);
|
|
}
|
|
|
|
#pragma warning(disable: 4715) // ok not to return a value here
|
|
|
|
Alg_event_ptr &Alg_seq::operator[](int i)
|
|
{
|
|
int ntracks = track_list.length();
|
|
int tr = 0;
|
|
while (tr < ntracks) {
|
|
Alg_track *a_track = track(tr);
|
|
if (a_track && i < a_track->length()) {
|
|
return (*a_track)[i];
|
|
} else if (a_track) {
|
|
i -= a_track->length();
|
|
}
|
|
tr++;
|
|
}
|
|
assert(false); // out of bounds
|
|
}
|
|
#pragma warning(default: 4715)
|
|
|
|
|
|
void Alg_seq::convert_to_beats()
|
|
{
|
|
if (!units_are_seconds) return;
|
|
for (int i = 0; i < tracks(); i++) {
|
|
track(i)->convert_to_beats();
|
|
}
|
|
// note that the Alg_seq inherits units_are_seconds from an
|
|
// empty track. Each track also has a (redundant) field called
|
|
// units are seconds. These should always be consistent.
|
|
units_are_seconds = false;
|
|
}
|
|
|
|
|
|
void Alg_seq::convert_to_seconds()
|
|
{
|
|
if (units_are_seconds) return;
|
|
//printf("convert_to_seconds, tracks %d\n", tracks());
|
|
//printf("last_tempo of seq: %g on map %x\n",
|
|
// get_time_map()->last_tempo, get_time_map());
|
|
for (int i = 0; i < tracks(); i++) {
|
|
//printf("last_tempo of track %d: %g on %x\n", i,
|
|
// track(i)->get_time_map()->last_tempo,
|
|
// track(i)->get_time_map());
|
|
track(i)->convert_to_seconds();
|
|
}
|
|
// update our copy of last_note_off (which may or may not be valid)
|
|
last_note_off = time_map->beat_to_time(last_note_off);
|
|
// note that the Alg_seq inherits units_are_seconds from an
|
|
// empty track. Each track also has a (redundant) field called
|
|
// units are seconds. These should always be consistent.
|
|
units_are_seconds = true;
|
|
}
|
|
|
|
|
|
Alg_track_ptr Alg_seq::cut_from_track(int track_num, double start,
|
|
double dur, bool all)
|
|
{
|
|
assert(track_num >= 0 && track_num < tracks());
|
|
Alg_track_ptr tr = track(track_num);
|
|
return tr->cut(start, dur, all);
|
|
}
|
|
|
|
|
|
void Alg_seq::copy_time_sigs_to(Alg_seq *dest)
|
|
{
|
|
// copy time signatures
|
|
for (int i = 0; i < time_sig.length(); i++) {
|
|
dest->time_sig.insert(time_sig[i].beat, time_sig[i].num,
|
|
time_sig[i].den);
|
|
}
|
|
}
|
|
|
|
|
|
void Alg_seq::set_time_map(Alg_time_map *map)
|
|
{
|
|
Alg_track::set_time_map(map);
|
|
for (int i = 0; i < tracks(); i++) {
|
|
track(i)->set_time_map(map);
|
|
}
|
|
}
|
|
|
|
|
|
Alg_seq_ptr Alg_seq::cut(double start, double len, bool all)
|
|
// return sequence from start to start+len and modify this
|
|
// sequence by removing that time-span
|
|
{
|
|
double dur = get_dur();
|
|
// fix parameters to fall within existing sequence
|
|
if (start > dur) return NULL; // nothing to cut
|
|
if (start < 0) start = 0; // can't start before sequence starts
|
|
if (start + len > dur) // can't cut after end:
|
|
len = dur - start;
|
|
|
|
Alg_seq_ptr result = new Alg_seq();
|
|
Alg_time_map_ptr map = new Alg_time_map(get_time_map());
|
|
result->set_time_map(map);
|
|
copy_time_sigs_to(result);
|
|
result->units_are_seconds = units_are_seconds;
|
|
result->track_list.reset();
|
|
|
|
for (int i = 0; i < tracks(); i++) {
|
|
Alg_track_ptr cut_track = cut_from_track(i, start, len, all);
|
|
result->track_list.append(cut_track);
|
|
// initially, result->last_note_off is zero. We want to know the
|
|
// maximum over all cut_tracks, so compute that here:
|
|
result->last_note_off = MAX(result->last_note_off,
|
|
cut_track->last_note_off);
|
|
// since we're moving to a new sequence, change the track's time_map
|
|
result->track_list[i].set_time_map(map);
|
|
}
|
|
|
|
// put units in beats to match time_sig's. Note that we need
|
|
// two different end times. For result, we want the time of the
|
|
// last note off, but for cutting out the time signatures in this,
|
|
// we use len.
|
|
double ts_start = start;
|
|
double ts_end = start + len;
|
|
double ts_dur = dur;
|
|
double ts_last_note_off = start + result->last_note_off;
|
|
if (units_are_seconds) {
|
|
ts_start = time_map->time_to_beat(ts_start);
|
|
ts_end = time_map->time_to_beat(ts_end);
|
|
ts_last_note_off = time_map->time_to_beat(ts_last_note_off);
|
|
ts_dur = time_map->time_to_beat(ts_dur);
|
|
}
|
|
// result is shifted from start to 0 and has length len, but
|
|
// time_sig and time_map are copies from this. Adjust time_sig,
|
|
// time_map, and duration fields in result. The time_sig and
|
|
// time_map data is retained out to last_note_off so that we have
|
|
// information for the entire duration of all the notes, even though
|
|
// this might extend beyond the duration of the track. (Warning:
|
|
// no info is retained for notes with negative times.)
|
|
result->time_sig.trim(ts_start, ts_last_note_off);
|
|
result->time_map->trim(start, start + result->last_note_off,
|
|
result->units_are_seconds);
|
|
// even though there might be notes sticking out beyond len, the
|
|
// track duration is len, not last_note_off. (Warning: if all is
|
|
// true, there may also be notes at negative offsets. These times
|
|
// cannot be mapped between beat and time representations, so there
|
|
// may be subtle bugs or unexpected behaviors in that case.)
|
|
result->set_dur(len);
|
|
|
|
// we sliced out a portion of each track, so now we need to
|
|
// slice out the corresponding sections of time_sig and time_map
|
|
// as well as to adjust the duration.
|
|
time_sig.cut(ts_start, ts_end, ts_dur);
|
|
time_map->cut(start, len, units_are_seconds);
|
|
set_dur(dur - len);
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
void Alg_seq::insert_silence_in_track(int track_num, double t, double len)
|
|
{
|
|
Alg_track_ptr tr = track(track_num);
|
|
tr->insert_silence(t, len);
|
|
}
|
|
|
|
|
|
void Alg_seq::insert_silence(double t, double len)
|
|
{
|
|
for (int i = 0; i < tracks(); i++) {
|
|
insert_silence_in_track(i, t, len);
|
|
}
|
|
double t_beats = t;
|
|
double len_beats = len;
|
|
// insert into time_sig array; use time_sig_paste,
|
|
// which requires us to build a simple time_sig array
|
|
if (units_are_seconds) {
|
|
time_map->insert_time(t, len);
|
|
t_beats = time_map->time_to_beat(t);
|
|
len_beats = time_map->time_to_beat(t + len) - t_beats;
|
|
} else {
|
|
time_map->insert_beats(t_beats, len_beats);
|
|
}
|
|
time_sig.insert_beats(t_beats, len_beats);
|
|
// Final duration is defined to be t + len + whatever was
|
|
// in the sequence after t (if any). This translates to
|
|
// t + len + max(dur - t, 0)
|
|
set_dur(t + len + max(get_dur() - t, 0.0));
|
|
}
|
|
|
|
|
|
Alg_track_ptr Alg_seq::copy_track(int track_num, double t, double len, bool all)
|
|
{
|
|
return track_list[track_num].copy(t, len, all);
|
|
}
|
|
|
|
|
|
Alg_seq *Alg_seq::copy(double start, double len, bool all)
|
|
{
|
|
// fix parameters to fall within existing sequence
|
|
if (start > get_dur()) return NULL; // nothing to copy
|
|
if (start < 0) start = 0; // can't copy before sequence starts
|
|
if (start + len > get_dur()) // can't copy after end:
|
|
len = get_dur() - start;
|
|
|
|
// return (new) sequence from start to start + len
|
|
Alg_seq_ptr result = new Alg_seq();
|
|
Alg_time_map_ptr map = new Alg_time_map(get_time_map());
|
|
result->set_time_map(map);
|
|
copy_time_sigs_to(result);
|
|
result->units_are_seconds = units_are_seconds;
|
|
result->track_list.reset();
|
|
|
|
for (int i = 0; i < tracks(); i++) {
|
|
Alg_track_ptr copy = copy_track(i, start, len, all);
|
|
result->track_list.append(copy);
|
|
result->last_note_off = MAX(result->last_note_off,
|
|
copy->last_note_off);
|
|
// since we're copying to a new seq, change the track's time_map
|
|
result->track_list[i].set_time_map(map);
|
|
}
|
|
|
|
// put units in beats to match time_sig's. Note that we need
|
|
// two different end times. For result, we want the time of the
|
|
// last note off, but for cutting out the time signatures in this,
|
|
// we use len.
|
|
double ts_start = start;
|
|
double ts_end = start + len;
|
|
double ts_last_note_off = start + result->last_note_off;
|
|
if (units_are_seconds) {
|
|
ts_start = time_map->time_to_beat(ts_start);
|
|
ts_end = time_map->time_to_beat(ts_end);
|
|
ts_last_note_off = time_map->time_to_beat(ts_last_note_off);
|
|
}
|
|
|
|
result->time_sig.trim(ts_start, ts_last_note_off);
|
|
result->time_map->trim(start, start + result->last_note_off,
|
|
units_are_seconds);
|
|
result->set_dur(len);
|
|
return result;
|
|
}
|
|
|
|
|
|
void Alg_seq::paste(double start, Alg_seq *seq)
|
|
{
|
|
// Insert seq at time, opening up space for it.
|
|
// To manipulate time map, we need units as beats.
|
|
// Save original form so we can convert back if necessary.
|
|
bool units_should_be_seconds = units_are_seconds;
|
|
bool seq_units_should_be_seconds = seq->get_units_are_seconds();
|
|
if (units_are_seconds) {
|
|
start = time_map->time_to_beat(start);
|
|
convert_to_beats();
|
|
}
|
|
seq->convert_to_beats();
|
|
|
|
// do a paste on each track
|
|
int i;
|
|
for (i = 0; i < seq->tracks(); i++) {
|
|
if (i >= tracks()) {
|
|
add_track(i);
|
|
}
|
|
track(i)->paste(start, seq->track(i));
|
|
}
|
|
// make sure all tracks were opened up for an insert, even if
|
|
// there is nothing to insert
|
|
while (i < tracks()) {
|
|
track(i)->insert_silence(start, seq->get_dur());
|
|
i++;
|
|
}
|
|
// paste in tempo track
|
|
time_map->paste(start, seq);
|
|
// paste in time signatures
|
|
time_sig.paste(start, seq);
|
|
set_dur(get_beat_dur() + seq->get_dur());
|
|
assert(!seq->units_are_seconds && !units_are_seconds);
|
|
if (units_should_be_seconds) {
|
|
convert_to_seconds();
|
|
}
|
|
if (seq_units_should_be_seconds) {
|
|
seq->convert_to_seconds();
|
|
}
|
|
}
|
|
|
|
|
|
void Alg_seq::merge(double t, Alg_event_list_ptr seq)
|
|
{
|
|
// seq must be an Alg_seq:
|
|
assert(seq->get_type() == 's');
|
|
Alg_seq_ptr s = (Alg_seq_ptr) seq;
|
|
for (int i = 0; i < s->tracks(); i++) {
|
|
if (tracks() <= i) add_track(i);
|
|
track(i)->merge(t, s->track(i));
|
|
}
|
|
}
|
|
|
|
|
|
void Alg_seq::silence_track(int track_num, double start, double len, bool all)
|
|
{
|
|
// remove events in [time, time + len) and close gap
|
|
Alg_track_ptr tr = track(track_num);
|
|
tr->silence(start, len, all);
|
|
}
|
|
|
|
|
|
void Alg_seq::silence(double t, double len, bool all)
|
|
{
|
|
for (int i = 0; i < tracks(); i++) {
|
|
silence_track(i, t, len, all);
|
|
}
|
|
}
|
|
|
|
|
|
void Alg_seq::clear_track(int track_num, double start, double len, bool all)
|
|
{
|
|
// remove events in [time, time + len) and close gap
|
|
Alg_track_ptr tr = track(track_num);
|
|
tr->clear(start, len, all);
|
|
}
|
|
|
|
|
|
void Alg_seq::clear(double start, double len, bool all)
|
|
{
|
|
// Fix parameters to fall within existing sequence
|
|
double dur = get_dur();
|
|
if (start > dur) return; // nothing to cut
|
|
if (start < 0) start = 0; // can't start before sequence starts
|
|
if (start + len > dur) // can't cut after end:
|
|
len = dur - start;
|
|
|
|
for (int i = 0; i < tracks(); i++)
|
|
clear_track(i, start, len, all);
|
|
|
|
// Put units in beats to match time_sig's.
|
|
double ts_start = start;
|
|
double ts_end = start + len;
|
|
double ts_dur = dur;
|
|
if (units_are_seconds) {
|
|
ts_start = time_map->time_to_beat(ts_start);
|
|
ts_end = time_map->time_to_beat(ts_end);
|
|
ts_dur = time_map->time_to_beat(ts_dur);
|
|
}
|
|
|
|
// we sliced out a portion of each track, so now we need to
|
|
// slice out the corresponding sections of time_sig and time_map
|
|
// as well as to adjust the duration.
|
|
time_sig.cut(ts_start, ts_end, ts_dur);
|
|
time_map->cut(start, len, units_are_seconds);
|
|
set_dur(dur - len);
|
|
}
|
|
|
|
|
|
Alg_event_list_ptr Alg_seq::find_in_track(int track_num, double t, double len,
|
|
bool all, int32_t channel_mask,
|
|
int32_t event_type_mask)
|
|
{
|
|
return track(track_num)->find(t, len, all, channel_mask, event_type_mask);
|
|
}
|
|
|
|
|
|
Alg_seq::~Alg_seq()
|
|
{
|
|
int i, j;
|
|
// Tracks does not delete Alg_events elements
|
|
for (j = 0; j < track_list.length(); j++) {
|
|
Alg_track ¬es = track_list[j];
|
|
// Alg_events does not delete notes
|
|
for (i = 0; i < notes.length(); i++) {
|
|
Alg_event_ptr event = notes[i];
|
|
delete event;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
long Alg_seq::seek_time(double time, int track_num)
|
|
// find index of first score event after time
|
|
{
|
|
long i;
|
|
Alg_events ¬es = track_list[track_num];
|
|
for (i = 0; i < notes.length(); i++) {
|
|
if (notes[i]->time > time) {
|
|
break;
|
|
}
|
|
}
|
|
return i;
|
|
}
|
|
|
|
|
|
bool Alg_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
|
|
time_map->insert_beat(time, beat);
|
|
return true;
|
|
}
|
|
|
|
|
|
// input is time, return value is time
|
|
double Alg_seq::nearest_beat_time(double time, double *beat)
|
|
{
|
|
double b = time_map->time_to_beat(time);
|
|
b = time_sig.nearest_beat(b);
|
|
if (beat) *beat = b;
|
|
return time_map->beat_to_time(b);
|
|
}
|
|
|
|
|
|
bool Alg_seq::stretch_region(double b0, double b1, double dur)
|
|
{
|
|
bool units_should_be_seconds = units_are_seconds;
|
|
convert_to_beats();
|
|
bool result = time_map->stretch_region(b0, b1, dur);
|
|
if (units_should_be_seconds) convert_to_seconds();
|
|
return result;
|
|
}
|
|
|
|
|
|
bool Alg_seq::insert_tempo(double bpm, double beat)
|
|
{
|
|
double bps = bpm / 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 = time_map->beat_to_time(beat);
|
|
long i = time_map->locate_time(time);
|
|
if (i >= time_map->beats.len || !within(time_map->beats[i].time, time, 0.000001)) {
|
|
insert_beat(time, beat);
|
|
}
|
|
// now i is index of beat where tempo will change
|
|
if (i == time_map->beats.len - 1) {
|
|
time_map->last_tempo = bps;
|
|
time_map->last_tempo_flag = true;
|
|
} else { // adjust all future beats
|
|
// compute the difference in beats
|
|
double diff = time_map->beats[i + 1].beat - time_map->beats[i].beat;
|
|
// convert beat difference to seconds at new tempo
|
|
diff = diff / bps;
|
|
// figure out old time difference:
|
|
double old_diff = time_map->beats[i + 1].time - time;
|
|
// compute difference too
|
|
diff = diff - old_diff;
|
|
// apply new_diff to score and beats
|
|
while (i < time_map->beats.len) {
|
|
time_map->beats[i].time = time_map->beats[i].time + diff;
|
|
i++;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
|
|
void Alg_seq::add_event(Alg_event_ptr event, int track_num)
|
|
// add_event puts an event in a given track (track_num).
|
|
// The track must exist. The time and duration of the
|
|
// event are interpreted according to whether the Alg_seq
|
|
// is currently in beats or seconds (see convert_to_beats())
|
|
{
|
|
track_list[track_num].insert(event);
|
|
/*
|
|
if (event->is_note()) {
|
|
Alg_note_ptr n = (Alg_note_ptr) event;
|
|
trace("note %d at %g for %g\n", n->get_identifier(), n->time, n->dur);
|
|
}
|
|
*/
|
|
}
|
|
|
|
|
|
double Alg_seq::get_tempo(double beat)
|
|
{
|
|
return time_map->get_tempo(beat);
|
|
}
|
|
|
|
|
|
bool Alg_seq::set_tempo(double bpm, double start_beat, double end_beat)
|
|
// set tempo from start_beat to end_beat
|
|
{
|
|
// this is an optimization, the test is repeated in Alg_time_seq::set_tempo()
|
|
if (start_beat >= end_beat) return false;
|
|
bool units_should_be_seconds = units_are_seconds;
|
|
convert_to_beats();
|
|
double dur = get_dur();
|
|
bool result = time_map->set_tempo(bpm, start_beat, end_beat);
|
|
// preserve sequence duration in beats when tempo changes
|
|
set_dur(dur);
|
|
if (units_should_be_seconds) convert_to_seconds();
|
|
return result;
|
|
}
|
|
|
|
|
|
double Alg_seq::get_bar_len(double beat)
|
|
{
|
|
return time_sig.get_bar_len(beat);
|
|
}
|
|
|
|
|
|
void Alg_seq::set_time_sig(double beat, double num, double den)
|
|
{
|
|
time_sig.insert(beat, num, den);
|
|
}
|
|
|
|
|
|
void Alg_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;
|
|
bpm = 4;
|
|
// assume 4/4 if no time signature
|
|
double prev_beat = 0;
|
|
double prev_num = 4;
|
|
double prev_den = 4;
|
|
|
|
if (beat < 0) beat = 0; // negative measures treated as zero
|
|
|
|
for (tsx = 0; tsx < time_sig.length(); tsx++) {
|
|
if (time_sig[tsx].beat <= beat) {
|
|
// 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);
|
|
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;
|
|
} else {
|
|
m = m + (beat - prev_beat) / bpm;
|
|
*measure = (long) m;
|
|
*m_beat = (m - *measure) * bpm;
|
|
*num = prev_num;
|
|
*den = prev_den;
|
|
return;
|
|
}
|
|
}
|
|
// if we didn't return yet, compute after last time signature
|
|
Alg_time_sig initial(0, 4, 4);
|
|
Alg_time_sig &prev = initial;
|
|
if (tsx > 0) { // use last time signature
|
|
prev = time_sig[time_sig.length() - 1];
|
|
}
|
|
bpm = prev.num * 4 / prev.den;
|
|
m = m + (beat - prev.beat) / bpm;
|
|
*measure = (long) m;
|
|
*m_beat = (m - *measure) * bpm;
|
|
*num = prev.num;
|
|
*den = prev.den;
|
|
}
|
|
|
|
/*
|
|
void Alg_seq::set_events(Alg_event_ptr *events, long len, long max)
|
|
{
|
|
convert_to_seconds(); // because notes are in seconds
|
|
notes.set_events(events, len, max);
|
|
}
|
|
*/
|
|
|
|
|
|
void Alg_iterator::begin_seq(Alg_seq_ptr s, void *cookie, double offset)
|
|
{
|
|
// keep an array of indexes into tracks
|
|
// printf("new pending\n");
|
|
int i;
|
|
for (i = 0; i < s->track_list.length(); i++) {
|
|
if (s->track_list[i].length() > 0) {
|
|
insert(&(s->track_list[i]), 0, true, cookie, offset);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
Alg_event_ptr Alg_iterator::next(bool *note_on, void **cookie_ptr,
|
|
double *offset_ptr, double end_time)
|
|
// return the next event in time from any track
|
|
{
|
|
bool on;
|
|
double when;
|
|
if (!remove_next(events_ptr, index, on, cookie, offset, when)) {
|
|
return NULL;
|
|
}
|
|
if (note_on) *note_on = on;
|
|
Alg_event_ptr event = (*events_ptr)[index];
|
|
if (on) {
|
|
if (note_off_flag && event->is_note() &&
|
|
(end_time == 0 ||
|
|
(*events_ptr)[index]->get_end_time() + offset < end_time)) {
|
|
// this was a note-on, so insert pending note-off
|
|
insert(events_ptr, index, false, cookie, offset);
|
|
}
|
|
// for both note-ons and updates, insert next event (at index + 1)
|
|
// DO NOT INCREMENT index: it must be preserved for request_note_off()
|
|
if (index + 1 < events_ptr->length() &&
|
|
(end_time == 0 || // zero means ignore end time
|
|
// stop iterating when end time is reached
|
|
(*events_ptr)[index + 1]->time + offset < end_time)) {
|
|
insert(events_ptr, index + 1, true, cookie, offset);
|
|
}
|
|
}
|
|
if (cookie_ptr) *cookie_ptr = cookie;
|
|
if (offset_ptr) *offset_ptr = offset;
|
|
return event;
|
|
}
|
|
|
|
|
|
void Alg_iterator::request_note_off()
|
|
{
|
|
assert(index >= 0 && index < events_ptr->length());
|
|
insert(events_ptr, index, false, cookie, offset);
|
|
}
|
|
|
|
|
|
void Alg_iterator::end()
|
|
{
|
|
}
|
|
|
|
|
|
void Alg_seq::merge_tracks()
|
|
{
|
|
long sum = 0;
|
|
long i;
|
|
for (i = 0; i < track_list.length(); i++) {
|
|
sum = sum + track(i)->length();
|
|
}
|
|
// preallocate array for efficiency:
|
|
Alg_event_ptr *notes = new Alg_event_ptr[sum];
|
|
Alg_iterator iterator(this, false);
|
|
iterator.begin();
|
|
long notes_index = 0;
|
|
|
|
Alg_event_ptr event;
|
|
while ((event = iterator.next())) {
|
|
notes[notes_index++] = event;
|
|
}
|
|
track_list.reset(); // don't need them any more
|
|
add_track(0);
|
|
track(0)->set_events(notes, sum, sum);
|
|
iterator.end();
|
|
}
|
|
|
|
|
|
void Alg_seq::set_in_use(bool flag)
|
|
{
|
|
Alg_track::set_in_use(flag);
|
|
track_list.set_in_use(flag);
|
|
}
|
|
|
|
|
|
// sr_letter_to_type = {"i": 'Integer', "r": 'Real', "s": 'String',
|
|
// "l": 'Logical', "a": 'Symbol'}
|
|
|
|
|