song.c

   1 /*
   2
   3     Ann Hell Ex Machina - Music Software
   4     Copyright (C) 2003/2007 Angel Ortega <angel@triptico.com>
   5
   6     song.c - Device-independent song event stream management
   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 "ahxm.h"
  34
  35 /*******************
  36         Data
  37 ********************/
  38
  39 /* the song event stream */
  40 struct song_ev *song = NULL;
  41
  42 /* number of song events */
  43 int n_song_ev = 0;
  44
  45 /* number of tracks in song */
  46 int n_song_tracks = 0;
  47
  48 /*******************
  49         Code
  50 ********************/
  51
  52 /**
  53  * add_event - Adds an event to an event list.
  54  * @song: A pointer to an event list (dynamically allocated)
  55  * @count: A pointer to an integer (number of elements)
  56  *
  57  * Increments the @song event list to fit @count number of
  58  * elements, probably reallocating its memory.
  59  *
  60  * Returns a pointer to the new element.
  61  */
  62 struct song_ev * add_event(struct song_ev **song, int *count)
  63 {
  64         struct song_ev * r;
  65
  66         GROW(*song, *count, struct song_ev);
  67
  68         r = *song + *count;
  69         memset(r, '\0', sizeof(struct song_ev));
  70
  71         (*count)++;
  72
  73         return r;
  74 }
  75
  76
  77 /**
  78  * copy_event - Appends an event to an event list.
  79  * @song: the event list
  80  * @count: a pointer to the number of elements
  81  * @e: the event to be copied
  82  *
  83  * Appends the @e event to the @song event list.
  84  */
  85 struct song_ev * copy_event(struct song_ev **song, int *count, struct song_ev *e)
  86 {
  87         struct song_ev * r = add_event(song, count);
  88
  89         memcpy(r, e, sizeof(struct song_ev));
  90
  91         return r;
  92 }
  93
  94
  95 /**
  96  * song_clear - Clears the song stream
  97  *
  98  * Clears the song stream.
  99  */
 100 void song_clear(void)
 101 {
 102         if (song != NULL) {
 103                 free(song);
 104                 song = NULL;
 105         }
 106
 107         n_song_ev = 0;
 108 }
 109
 110
 111 static void song_trace_events(void)
 112 {
 113         struct song_ev *e;
 114         int n;
 115
 116         printf("** GENERIC SONG EVENT DUMP **\n\n");
 117         printf("%9s %5s %5s Event and information\n", "Time", "Track", "Ev.ID");
 118         printf("---------------------------------------------------------------\n");
 119
 120         for (n = 0, e = song; n < n_song_ev; n++, e++) {
 121                 printf("%9.4lf %5d %5d ",
 122                        e->time, e->trk_id, e->event_id);
 123
 124                 switch (e->type) {
 125                 case SONG_EV_TEMPO:
 126
 127                         printf("SONG_EV_TEMPO ");
 128                         printf("TEMPO:%lf", e->amount);
 129                         break;
 130
 131                 case SONG_EV_METER:
 132
 133                         printf("SONG_EV_METER ");
 134                         printf("METER:%d/%d", e->min, e->max);
 135                         break;
 136
 137                 case SONG_EV_MEASURE:
 138
 139                         printf("SONG_EV_MEASURE ");
 140                         printf("LINE:%d", e->value);
 141                         break;
 142
 143                 case SONG_EV_SS_SUSTAIN:
 144
 145                         printf("SONG_EV_SS_SUSTAIN ");
 146                         printf("SUSTAIN:%lf", e->amount);
 147                         break;
 148
 149                 case SONG_EV_SS_VIBRATO:
 150
 151                         printf("SONG_EV_SS_VIBRATO ");
 152                         printf("DEPTH:%lf FREQ:%lf", e->depth, e->freq);
 153                         break;
 154
 155                 case SONG_EV_SS_PORTAMENTO:
 156
 157                         printf("SONG_EV_SS_PORTAMENTO ");
 158                         printf("VALUE: %lf", e->amount);
 159                         break;
 160
 161                 case SONG_EV_SS_CHANNEL:
 162
 163                         printf("SONG_EV_SS_CHANNEL ");
 164                         printf("CHANNEL:%d VOL:%lf", e->channel, e->vol);
 165                         break;
 166
 167                 case SONG_EV_SS_WAV:
 168
 169                         printf("SONG_EV_SS_WAV ");
 170                         printf("FILE:'%s' BASE:%d MIN:%d MAX:%d START:%lf END:%lf",
 171                                e->name, e->value,
 172                                e->min, e->max,
 173                                e->start, e->end);
 174                         break;
 175
 176                 case SONG_EV_SS_PAT:
 177
 178                         printf("SONG_EV_SS_PAT ");
 179                         printf("FILE:'%s'", e->name);
 180                         break;
 181
 182                 case SONG_EV_SS_EFF_DELAY:
 183
 184                         printf("SONG_EV_SS_EFF_DELAY ");
 185                         printf("CHANNEL:%d ", e->channel);
 186                         printf("SIZE:%lf ", e->len);
 187                         break;
 188
 189                 case SONG_EV_SS_EFF_ECHO:
 190
 191                         printf("SONG_EV_SS_EFF_ECHO ");
 192                         printf("CHANNEL:%d ", e->channel);
 193                         printf("SIZE:%lf ", e->len);
 194                         printf("GAIN:%f ", e->vol);
 195                         break;
 196
 197                 case SONG_EV_SS_EFF_COMB:
 198
 199                         printf("SONG_EV_SS_EFF_COMB ");
 200                         printf("CHANNEL:%d ", e->channel);
 201                         printf("SIZE:%lf ", e->len);
 202                         printf("GAIN:%f ", e->vol);
 203                         break;
 204
 205                 case SONG_EV_SS_EFF_ALLPASS:
 206
 207                         printf("SONG_EV_SS_EFF_ALLPASS ");
 208                         printf("CHANNEL:%d ", e->channel);
 209                         printf("SIZE:%lf ", e->len);
 210                         printf("GAIN:%f ", e->vol);
 211                         break;
 212
 213                 case SONG_EV_SS_EFF_FLANGER:
 214
 215                         printf("SONG_EV_SS_EFF_FLANGER ");
 216                         printf("CHANNEL:%d ", e->channel);
 217                         printf("SIZE:%lf ", e->len);
 218                         printf("GAIN:%f ", e->vol);
 219                         printf("DEPTH:%lf ", e->depth);
 220                         printf("FREQ:%lf PHASE:%lf", e->freq, e->phase);
 221                         break;
 222
 223                 case SONG_EV_SS_EFF_WOBBLE:
 224
 225                         printf("SONG_EV_SS_EFF_WOBBLE ");
 226                         printf("CHANNEL:%d ", e->channel);
 227                         printf("FREQ:%lf PHASE:%lf GAIN:%lf", e->freq,
 228                                e->phase, e->vol);
 229                         break;
 230
 231                 case SONG_EV_SS_EFF_SQWOBBLE:
 232
 233                         printf("SONG_EV_SS_EFF_SQWOBBLE ");
 234                         printf("CHANNEL:%d ", e->channel);
 235                         printf("FREQ:%lf PHASE:%lf", e->freq, e->phase);
 236                         break;
 237
 238                 case SONG_EV_SS_EFF_HFWOBBLE:
 239
 240                         printf("SONG_EV_SS_EFF_HFWOBBLE ");
 241                         printf("CHANNEL:%d ", e->channel);
 242                         printf("FREQ:%lf PHASE:%lf", e->freq, e->phase);
 243                         break;
 244
 245                 case SONG_EV_SS_EFF_FADER:
 246
 247                         printf("SONG_EV_SS_EFF_FADER ");
 248                         printf("CHANNEL:%d ", e->channel);
 249                         printf("SIZE:%lf ", e->len);
 250                         printf("INITIAL:%f FINAL:%f", e->initial, e->final);
 251                         break;
 252
 253                 case SONG_EV_SS_EFF_REVERB:
 254
 255                         printf("SONG_EV_SS_EFF_REVERB ");
 256                         printf("CHANNEL:%d ", e->channel);
 257                         break;
 258
 259                 case SONG_EV_SS_EFF_FOLDBACK:
 260
 261                         printf("SONG_EV_SS_EFF_FOLDBACK ");
 262                         printf("CHANNEL:%d THRESHOLD:%f", e->channel, e->vol);
 263                         break;
 264
 265                 case SONG_EV_SS_EFF_ATAN:
 266
 267                         printf("SONG_EV_SS_EFF_ATAN ");
 268                         printf("CHANNEL:%d GAIN:%f", e->channel, e->vol);
 269                         break;
 270
 271                 case SONG_EV_SS_EFF_DISTORT:
 272
 273                         printf("SONG_EV_SS_EFF_DISTORT ");
 274                         printf("CHANNEL:%d GAIN:%f", e->channel, e->vol);
 275                         break;
 276
 277                 case SONG_EV_SS_EFF_OVERDRIVE:
 278
 279                         printf("SONG_EV_SS_EFF_OVERDRIVE ");
 280                         printf("CHANNEL:%d GAIN:%f", e->channel, e->vol);
 281                         break;
 282
 283                 case SONG_EV_SS_EFF_OFF:
 284
 285                         printf("SONG_EV_SS_EFF_OFF ");
 286                         printf("CHANNEL:%d ", e->channel);
 287                         break;
 288
 289                 case SONG_EV_MIDI_CHANNEL:
 290
 291                         printf("SONG_EV_MIDI_CHANNEL ");
 292                         printf("CHANNEL:%d ", e->channel);
 293                         break;
 294
 295                 case SONG_EV_MIDI_PROGRAM:
 296
 297                         printf("SONG_EV_MIDI_PROGRAM ");
 298                         printf("PROGRAM:%d ", e->value);
 299                         break;
 300
 301                 case SONG_EV_BACK:
 302
 303                         printf("SONG_EV_BACK ");
 304                         printf("LEN:%lf", e->len);
 305                         break;
 306
 307                 case SONG_EV_NOTE:
 308
 309                         printf("SONG_EV_NOTE ");
 310                         printf("MIDI:%d LEN:%lf VOL:%f", e->value, e->len, e->vol);
 311                         break;
 312
 313                 case SONG_EV_SS_PITCH_STRETCH:
 314
 315                         printf("SONG_EV_SS_PITCH_STRETCH ");
 316                         printf("MIDI:%d LEN:%lf VOL:%f", e->value, e->len, e->vol);
 317                         break;
 318
 319                 case SONG_EV_SS_PRINT_WAVE_TEMPO:
 320
 321                         printf("SONG_EV_SS_PRINT_WAVE_TEMPO ");
 322                         printf("MIDI:%d LEN:%lf", e->value, e->len);
 323                         break;
 324
 325                 case SONG_EV_SONG_INFO:
 326
 327                         printf("SONG_EV_SONG_INFO ");
 328                         printf("AUTHOR:'%s' NAME:'%s'", e->author, e->name);
 329                         break;
 330
 331                 case SONG_EV_EOT:
 332
 333                         printf("SONG_EV_EOT ");
 334                         break;
 335
 336                 case SONG_EV_NOP:
 337
 338                         printf("SONG_EV_NOP ");
 339                         break;
 340
 341                 default:
 342                         printf("** Unexpected event type: %d", e->type);
 343                 }
 344
 345                 printf("\n");
 346         }
 347
 348         printf("\n");
 349 }
 350
 351
 352 static int time_type_eventid_cmp(const void *v1, const void *v2)
 353 /* sorts events by time, then type, then event_id */
 354 {
 355         struct song_ev *e1;
 356         struct song_ev *e2;
 357         int ret;
 358
 359         e1 = (struct song_ev *) v1;
 360         e2 = (struct song_ev *) v2;
 361
 362         ret = (int) ((e1->time * 10000.0) - (e2->time * 10000.0));
 363
 364         /* same time? order by type of event */
 365         if (ret == 0)
 366                 ret = e1->type - e2->type;
 367
 368         /* same time and same event? order by event id */
 369         if (ret == 0)
 370                 ret = e1->event_id - e2->event_id;
 371
 372         return ret;
 373 }
 374
 375
 376 static void count_tracks(void)
 377 /* sets n_song_tracks */
 378 {
 379         int n;
 380
 381         n_song_tracks = 0;
 382
 383         for(n = 0; n < n_song_ev; n++) {
 384                 struct song_ev *e;
 385
 386                 e = &song[n];
 387
 388                 if (n_song_tracks < e->trk_id + 1)
 389                         n_song_tracks = e->trk_id + 1;
 390         }
 391 }
 392
 393
 394 static void add_eot_events(void)
 395 /* travels all events and adds EOT ones */
 396 {
 397         int n, m;
 398
 399         for (n = 0; n < n_song_tracks; n++) {
 400                 struct song_ev *e;
 401                 double t = -1;
 402
 403                 for (m = 0; m < n_song_ev; m++) {
 404                         e = &song[m];
 405
 406                         /* if this is the track we're looking for
 407                            and this event time is bigger, store it */
 408                         if (e->trk_id == n && e->time > t)
 409                                 t = e->time;
 410                 }
 411
 412                 /* now t has the biggest time; add an EOT event with t */
 413                 e = add_event(&song, &n_song_ev);
 414
 415                 e->type = SONG_EV_EOT;
 416                 e->time = t;
 417                 e->trk_id = n;
 418                 e->event_id = n_song_ev - 1;
 419         }
 420 }
 421
 422
 423 /**
 424  * mute_tracks - Converts track events to NOPs.
 425  * @trk_id: Track to be muted. If negative, all buts this will be muted
 426  *
 427  * Converts events to NOP. If @trk_id is positive, all events for that
 428  * track id will be converted to NOP; if it's negative, all events BUT
 429  * for the ones in that track will be muted.
 430  */
 431 void mute_tracks(int trk_id)
 432 {
 433         int n;
 434
 435         for (n = 0; n < n_song_ev; n++) {
 436                 struct song_ev *e;
 437
 438                 e = &song[n];
 439
 440                 /* try only 'real' tracks */
 441                 if (e->trk_id >= 0) {
 442                         if (trk_id > 0) {
 443                                 if (e->trk_id == trk_id)
 444                                         e->type = SONG_EV_NOP;
 445                         }
 446                         else {
 447                                 if (e->trk_id != -trk_id)
 448                                         e->type = SONG_EV_NOP;
 449                         }
 450                 }
 451         }
 452 }
 453
 454
 455 /**
 456  * song_sort - Sorts the song stream
 457  *
 458  * Sorts the song stream.
 459  */
 460 void song_sort(void)
 461 {
 462         count_tracks();
 463         add_eot_events();
 464
 465         /* sorts by time, type and event_id */
 466         qsort(song, n_song_ev, sizeof(struct song_ev), time_type_eventid_cmp);
 467
 468         if (trace)
 469                 song_trace_events();
 470 }
 471
 472
 473 /**
 474  * song_test_measure_boundary - Does a measure boundary check
 475  * @ev_time: event time
 476  * @num: meter numerator
 477  * @den: meter denominator
 478  *
 479  * Does a measure boundary check. Returns 0 if the event time falls
 480  * exactly between two measures, or nonzero otherwise.
 481  */
 482 int song_test_measure_boundary(double ev_time, int num, int den, int line)
 483 {
 484         int ret;
 485
 486         if ((ret = ((int) (ev_time * (double) den)) % num))
 487                 printf("Measure boundary check failed in line %d\n", line);
 488
 489         return ret;
 490 }