From b6644478fd2a97e9bf8e1f81f6cf84a7956eed35 Mon Sep 17 00:00:00 2001 From: Davide Morelli Date: Fri, 2 Dec 2005 18:56:07 +0000 Subject: added switching style functions svn path=/trunk/externals/frankenstein/; revision=4117 --- common.c | 112 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++--- common.h | 105 ++++++++++++++++++++++++++++++++++++++++++++--------------- test.c | 4 +-- 3 files changed, 188 insertions(+), 33 deletions(-) diff --git a/common.c b/common.c index 4d554ff..a42c717 100755 --- a/common.c +++ b/common.c @@ -100,7 +100,7 @@ float duration2float(t_duration duration) return (float) (((float)duration.numerator) / ((float)duration.denominator)); } -void setFirstBeat(t_rhythm_event **firstEvent, unsigned short int voice, float fduration) +void setFirstBeat(t_rhythm_event **firstEvent, unsigned short int voice, float fduration, unsigned short int played) { t_duration res; t_rhythm_event *newElement; @@ -112,12 +112,13 @@ void setFirstBeat(t_rhythm_event **firstEvent, unsigned short int voice, float f newElement->previous = 0; newElement->next = 0; newElement->voice=voice; + newElement->played=played; newElement->duration.numerator = res.numerator; newElement->duration.denominator = res.denominator; *firstEvent = newElement; } -void concatenateBeat(t_rhythm_event *currentEvent, unsigned short int voice, float fduration) +void concatenateBeat(t_rhythm_event *currentEvent, unsigned short int voice, float fduration, unsigned short int played) { t_duration res; t_rhythm_event *newElement, *lastElement; @@ -133,6 +134,7 @@ void concatenateBeat(t_rhythm_event *currentEvent, unsigned short int voice, flo newElement->next = 0; lastElement->next = newElement; newElement->voice=voice; + newElement->played=played; newElement->duration.numerator = res.numerator; newElement->duration.denominator = res.denominator; @@ -165,7 +167,7 @@ void add_t_rhythm_memory_arc(t_rhythm_memory_node *srcNode, t_rhythm_memory_node // create a new arc newArc = (t_rhythm_memory_arc *) malloc(sizeof(t_rhythm_memory_arc)); - newArc->to_note = dstNode; + newArc->to_node = dstNode; newArc->weight = 1; // go to the last arc in the list // and add this arc as the last @@ -183,6 +185,108 @@ void add_t_rhythm_memory_arc(t_rhythm_memory_node *srcNode, t_rhythm_memory_node } } +// initialize this representation, allocates memory for the pointers +void init_rhythm_memory_representation(t_rhythm_memory_representation *this_rep) +{ + this_rep->transitions = (t_rhythm_memory_node *) malloc(sizeof(t_rhythm_memory_node) * possible_durations()); + this_rep->main_rhythm = 0; + this_rep->similar_rhythms = 0; +} + +// add a new rhythm in the list of similar thythms related to one main rhythm +void add_t_rhythm_memory_element(t_rhythm_memory_representation *this_rep, t_rhythm_event *new_rhythm) +{ + t_rhythm_memory_element *curr; + t_rhythm_memory_element *newElement; + // creates a new element of the list of similar rhythms + newElement = (t_rhythm_memory_element *) malloc(sizeof(t_rhythm_memory_element)); + newElement->rhythm = new_rhythm; + newElement->next = 0; + // finds the last element and adds itself + curr = this_rep->similar_rhythms; + if (curr) + { + while (curr->next) + curr=curr->next; + curr->next = newElement; + + } else + { + this_rep->similar_rhythms = newElement; + } + + +} + +// from (duration) to (start) style +void swap_rhythm_to_start(t_rhythm_event *oldStyle, t_rhythm_event **newStyle) +{ + t_rhythm_event *oldCurr, *newElement, *oldPrev; + float diff, currMoment; + t_duration dur_tmp; + + // allocate the first event + oldCurr = oldStyle; + oldPrev = 0; + currMoment = 0; + + // look for the first beat played in old rhythm + while (oldCurr && (! (oldCurr->played))) + { + // prepare for the next event + dur_tmp.numerator = oldCurr->duration.numerator; + dur_tmp.denominator = oldCurr->duration.denominator; + currMoment = duration2float(dur_tmp); + oldPrev = oldCurr; + oldCurr = oldCurr->next; + } + + if (currMoment == 0) + return; // empty rhythm?!? + + // now in currMoment there is the moment of the first played beat + // i can set the first one and initialize the new style + newElement = (t_rhythm_event *) malloc(sizeof(t_rhythm_event)); + *newStyle = newElement; + dur_tmp = float2duration(currMoment); + newElement->duration.numerator = dur_tmp.numerator; + newElement->duration.denominator = dur_tmp.denominator; + newElement->previous = oldPrev; + if (oldPrev) + oldPrev->next = newElement; + + while (oldCurr) + { + if (oldCurr->played) + { + // allocate a new element + newElement = (t_rhythm_event *) malloc(sizeof(t_rhythm_event)); + // set its value + dur_tmp = float2duration(currMoment); + newElement->duration.numerator = dur_tmp.numerator; + newElement->duration.denominator = dur_tmp.denominator; + newElement->previous = oldPrev; + if (oldPrev) + oldPrev->next = newElement; + } + // prepare for the next event + dur_tmp.numerator = oldCurr->duration.numerator; + dur_tmp.denominator = oldCurr->duration.denominator; + currMoment = duration2float(dur_tmp); + oldPrev = oldCurr; + oldCurr = oldCurr->next; + } + + +} + +// from (start) to (duration) style +void swap_rhythm_to_duration(t_rhythm_event *oldStyle, t_rhythm_event **newStyle) +{ + +} + + // ------------------- themes manipulation functions // set the first note of a sequence @@ -218,7 +322,7 @@ void concatenateNote(t_note_event *currentEvent, unsigned short int voice, float // convert from float to duration res = float2duration(fduration); // allocate a new element of the list - newElement = (t_rhythm_event *) malloc(sizeof(t_note_event)); + newElement = (t_note_event *) malloc(sizeof(t_note_event)); // set the pointers newElement->previous = lastElement; newElement->next = 0; diff --git a/common.h b/common.h index f5bc973..e447f1d 100755 --- a/common.h +++ b/common.h @@ -1,41 +1,47 @@ // here i put common data structures and functions +// ------------------------------------------------ data structures + + // --------- theme notation -// data structures -typedef struct _note +typedef struct t_note t_note; +typedef struct t_duration t_duration; +typedef struct t_note_event t_note_event; + +typedef struct t_note { unsigned short int played; // 0 if is a rest, 1 if played unsigned short int chord; // 0 if is not a chord (strong) note, 1 if it is unsigned short int diatonic; // 0 if is a note not belonging to this tonality int interval; // semitones from prefious note -} t_note; - -typedef struct _duration +}; +typedef struct t_duration { int numerator; // like in music notation: in a 1/4 note the numerator is 1 int denominator; // like in music notation: in a 1/4 note the denominator is 4 -} t_duration; - -typedef struct _note_event +}; +struct t_note_event { unsigned short int voice; t_note note; t_duration duration; - struct t_note_event *previous; // this is a list, link to the previous element - struct t_note_event *next; // this is a list, link to the next element -} t_note_event; + t_note_event *previous; // this is a list, link to the previous element + t_note_event *next; // this is a list, link to the next element +}; // --------- rhythm notation // data structures +// this describes a rhythm typedef struct t_rhythm_event t_rhythm_event; struct t_rhythm_event { unsigned short int voice; + unsigned short int played; // 0 if is a rest, 1 if played t_duration duration; t_rhythm_event *previous; // this is a list, link to the previous element t_rhythm_event *next; // this is a list, link to the next element @@ -43,35 +49,59 @@ struct t_rhythm_event // rhythms memory graph - // list implementation // this implements a graph that stores the memory of the current rhythm sub-elements // list of links // the actual implementation will be an array of nodes, each node + +// this describes a probability transition table typedef struct t_rhythm_memory_arc t_rhythm_memory_arc; typedef struct t_rhythm_memory_node t_rhythm_memory_node; // graph node -typedef struct t_rhythm_memory_node +struct t_rhythm_memory_node { t_duration duration; t_rhythm_memory_arc *arcs; // the list of arcs to other nodes } ; -// graph arc +// graph arc: related to t_rhythm_memory_node struct t_rhythm_memory_arc { unsigned short int weight; t_rhythm_memory_node *to_node; // the target of this link (arc) t_rhythm_memory_arc *next_arc; // next link in the list } ; -// it will be arranged in a heap list? - -// add an arc to this node -void add_t_rhythm_memory_arc(t_rhythm_memory_node *srcNode, t_rhythm_memory_node *dstNode); +// it will be arranged in a heap list.. ? #define num_possible_denominators 11 static unsigned short int possible_denominators[] = {1,2,3,4,6,8,12,16,18,24,32}; -// functions needed to fill and use the memory table +// this defines a space for rhythms, variations, transitions and representations +typedef struct t_rhythm_memory_representation t_rhythm_memory_representation; +typedef struct t_rhythm_memory_element t_rhythm_memory_element; +// element of a list of rhythms +struct t_rhythm_memory_element +{ + t_rhythm_event *rhythm; // this rhythm + t_rhythm_memory_element *next; // next element of the list +} ; +// a rhythm in memory, each rhythm is : +// - a main rhythm +// - its probability transition table +// - similar rhythms played +struct t_rhythm_memory_representation +{ + t_rhythm_memory_element *main_rhythm; + t_rhythm_memory_node *transitions; + t_rhythm_memory_element *similar_rhythms; +} ; + +// ------------------------------------------------ functions + +// ----------- rhythm manipolation functions + +// TODO: +// - from data structures to lists of numbers and vice versa +// - from a (voice, duration) representation to (voice, start, duration) and viceversa // converts from integer to duration: used to know this table index // what corresponds in terms of duration @@ -82,27 +112,48 @@ unsigned short int duration2int(t_duration dur); // tells you how many durations there are int possible_durations(); -// ----------- rhythm manipolation functions - -// TODO: -// - from data structures to lists of numbers and vice versa -// - from a (voice, duration) representation to (voice, start, duration) and viceversa - // converts from float (0-1) to duration. it performs quantization t_duration float2duration(float fduration); // converts from numerator/denominator to a float (0-1) float duration2float(t_duration duration); +// --- rhythms creation and manupulation functions + // set the first beat of a sequence -void setFirstBeat(t_rhythm_event **firstEvent, unsigned short int voice, float fduration); +void setFirstBeat(t_rhythm_event **firstEvent, unsigned short int voice, float fduration, unsigned short int played); //adds a beat at the end of this list -void concatenateBeat(t_rhythm_event *currentEvent, unsigned short int voice, float fduration); +void concatenateBeat(t_rhythm_event *currentEvent, unsigned short int voice, float fduration, unsigned short int played); // used to free the memory allocated by this list void freeBeats(t_rhythm_event *currentEvent); +// change rhythm description protocol + +// from (duration) to (start) style +// the (start) style is a list of noteon events, the order is not important +void swap_rhythm_to_start(t_rhythm_event *oldStyle, t_rhythm_event **newStyle); + +// from (start) to (duration) +// the (duration) style is a linked list of duration of both notes or rests, the order is important +void swap_rhythm_to_duration(t_rhythm_event *oldStyle, t_rhythm_event **newStyle); + +// --- memory representation of rhythms + +// add an arc to this node +void add_t_rhythm_memory_arc(t_rhythm_memory_node *srcNode, t_rhythm_memory_node *dstNode); + +// initialize this representation, allocates memory for the pointers +void init_rhythm_memory_representation(t_rhythm_memory_representation *this_rep); + +// add a new rhythm in the list of similar rhythms related to one main rhythm +void add_similar_rhythm(t_rhythm_memory_representation *this_rep, t_rhythm_event *new_rhythm); + +// functions needed to fill and use the memory table + + + // -------- notes manipulation functions // set the first beat of a sequence diff --git a/test.c b/test.c index 691d7a8..ebadac4 100755 --- a/test.c +++ b/test.c @@ -42,10 +42,10 @@ static void test_bang(t_test *x) { if (x->seq_initialized) { - concatenateBeat(x->seq, 0, rnd); + concatenateBeat(x->seq, 0, rnd, 1); } else { - setFirstBeat(&(x->seq), 0, rnd); + setFirstBeat(&(x->seq), 0, rnd, 1); x->seq_initialized = 1; } -- cgit v1.2.1