event.c

   1 /*
   2
   3     Ann Hell Ex Machina - Music Software
   4     Copyright (C) 2003/2004 Angel Ortega <angel@triptico.com>
   5
   6     event.c - Music events
   7
   8     This program is free software; you can redistribute it and/or
   9     modify it under the terms of the GNU General Public License
  10     as published by the Free Software Foundation; either version 2
  11     of the License, or (at your option) any later version.
  12
  13     This program is distributed in the hope that it will be useful,
  14     but WITHOUT ANY WARRANTY; without even the implied warranty of
  15     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16     GNU General Public License for more details.
  17
  18     You should have received a copy of the GNU General Public License
  19     along with this program; if not, write to the Free Software
  20     Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  21
  22     http://www.triptico.com
  23
  24 */
  25
  26 #include "config.h"
  27
  28 #include <stdio.h>
  29 #include <stdlib.h>
  30 #include <string.h>
  31 #include <math.h>
  32
  33 #include "core.h"
  34 #include "event.h"
  35
  36
  37 /*******************
  38         Data
  39 ********************/
  40
  41 /* stage 1 events */
  42 union event1 * _events_1=NULL;
  43
  44 /* number of events */
  45 int _n_events_1=0;
  46
  47 /* stage 2 events */
  48 union event2 * _events_2=NULL;
  49
  50 /* number of events */
  51 int _n_events_2=0;
  52
  53
  54 /*******************
  55         Code
  56 ********************/
  57
  58 void new_event1(union event1 * ev)
  59 {
  60         _n_events_1++;
  61
  62         /* reallocs */
  63         _events_1=(union event1 *)realloc(_events_1,
  64                 _n_events_1 * sizeof(union event1));
  65
  66         /* store */
  67         memcpy(&_events_1[_n_events_1 - 1], ev, sizeof(union event1));
  68 }
  69
  70
  71 void event1_clear(void)
  72 {
  73         union event1 e1;
  74
  75         if(_events_1 != NULL)
  76         {
  77                 free(_events_1);
  78                 _events_1=NULL;
  79         }
  80
  81         _n_events_1=0;
  82
  83         /* adds a default tempo */
  84         e1.tempo.type=EV1_TEMPO;
  85         e1.tempo.time=0;
  86         e1.tempo.trk_id=-2;
  87         e1.tempo.tempo=120.0;
  88
  89         new_event1(&e1);
  90 }
  91
  92
  93 static int _event1_cmp(const void * v1, const void * v2)
  94 {
  95         struct ev1_generic * e1;
  96         struct ev1_generic * e2;
  97
  98         e1=(struct ev1_generic *)v1; e2=(struct ev1_generic *)v2;
  99
 100         if(e1->time == e2->time)
 101                 return(e1->type - e2->type);
 102
 103         return(e1->time - e2->time);
 104 }
 105
 106
 107 void event1_sort(void)
 108 {
 109         struct ev1_generic e;
 110
 111         qsort(_events_1, _n_events_1, sizeof(union event1), _event1_cmp);
 112
 113         e.type=EV1_END;
 114         new_event1((union event1 *) &e);
 115 }
 116
 117
 118 /* stage 2 events */
 119
 120 void event2_clear(void)
 121 {
 122         if(_events_2 != NULL)
 123         {
 124                 free(_events_2);
 125                 _events_2=NULL;
 126         }
 127
 128         _n_events_2=0;
 129 }
 130
 131
 132 void new_event2(union event2 * ev)
 133 {
 134         _n_events_2++;
 135
 136         /* reallocs */
 137         _events_2=(union event2 *)realloc(_events_2,
 138                 _n_events_2 * sizeof(union event2));
 139
 140         /* store */
 141         memcpy(&_events_2[_n_events_2 - 1], ev, sizeof(union event2));
 142 }
 143
 144
 145 static int _event2_cmp(const void * v1, const void * v2)
 146 {
 147         struct ev2_generic * e1;
 148         struct ev2_generic * e2;
 149
 150         e1=(struct ev2_generic *)v1; e2=(struct ev2_generic *)v2;
 151
 152         if(e1->frame == e2->frame)
 153                 return(e1->type - e2->type);
 154
 155         return(e1->frame - e2->frame);
 156 }
 157
 158
 159 void event2_sort(void)
 160 {
 161         struct ev2_generic e;
 162
 163         qsort(_events_2, _n_events_2, sizeof(union event2), _event2_cmp);
 164
 165         e.type=EV2_END;
 166         new_event2((union event2 *) &e);
 167 }
 168
 169
 170 void event1_to_event2(void)
 171 {
 172         int note_id=1;
 173         union event1 * e1;
 174         union event2 e2;
 175         int frame, frame_ac;
 176         double tempo, time_ac;
 177
 178         event1_sort();
 179
 180         event2_clear();
 181
 182         tempo=0;
 183         frame_ac=0;
 184         time_ac=0;
 185
 186         for(e1=_events_1;e1->generic.type != EV1_END;e1++)
 187         {
 188                 frame=((e1->generic.time - time_ac) * tempo) + frame_ac;
 189
 190                 switch(e1->generic.type)
 191                 {
 192                 case EV1_TEMPO:
 193
 194                         /* updates accumulations */
 195                         frame_ac += frame;
 196                         time_ac += e1->generic.time;
 197
 198                         tempo=(double) _frequency * 60.0;
 199                         tempo /= e1->tempo.tempo / 4.0;
 200
 201                         break;
 202
 203                 case EV1_MEASURE:
 204
 205                         break;
 206
 207                 case EV1_NOTE:
 208
 209                         e2.note_on.type=EV2_NOTE_ON;
 210                         e2.note_on.frame=frame;
 211                         e2.note_on.trk_id=e1->note.trk_id;
 212                         e2.note_on.note_id=note_id;
 213                         e2.note_on.note=e1->note.note;
 214                         e2.note_on.vol=e1->note.vol;
 215
 216                         new_event2(&e2);
 217
 218                         e2.note_off.type=EV2_NOTE_OFF;
 219                         e2.note_off.frame += (int)(e1->note.len * tempo);
 220
 221                         new_event2(&e2);
 222
 223                         note_id++;
 224                 }
 225         }
 226
 227         event2_sort();
 228 }