ss_song.c

   1 /*
   2
   3     Ann Hell Ex Machina - Music Software
   4     Copyright (C) 2003/2007 Angel Ortega <angel@triptico.com>
   5
   6     ss_song.c - Software synth 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 softsynth song stream */
  40
  41 static struct song_ev *ss_song = NULL;
  42 static int n_ss_ev = 0;
  43
  44 /* the instruments */
  45
  46 struct ss_ins ss_song_ins[SS_MAX_INSTRUMENTS];
  47
  48 /*******************
  49         Code
  50 ********************/
  51
  52 static struct song_ev * add_ss_ev(const struct song_ev *e)
  53 /* adds a softsynth song event */
  54 {
  55         return copy_event(&ss_song, &n_ss_ev, e);
  56 }
  57
  58
  59 static int frame_type_eventid_cmp(const void *v1, const void *v2)
  60 /* softsynth song event compare function for qsort() */
  61 {
  62         struct song_ev *e1;
  63         struct song_ev *e2;
  64         int ret;
  65
  66         e1 = (struct song_ev *) v1;
  67         e2 = (struct song_ev *) v2;
  68
  69         ret = e1->frame - e2->frame;
  70
  71         if (ret == 0)
  72                 ret = e1->type - e2->type;
  73
  74         if (ret == 0)
  75                 ret = e1->event_id - e2->event_id;
  76
  77         return ret;
  78 }
  79
  80
  81 static void ss_song_convert_events(int *n_channels)
  82 /* converts generic song_ev events to softsynth events */
  83 {
  84         int note_id = 1;
  85         struct song_ev *e;
  86         int frame, frame_ac, f_frame;
  87         double fpw, time_ac, time_ac_m;
  88         int num, den;
  89         int n;
  90
  91         *n_channels = -1;
  92
  93         /* resets the ss stream */
  94         if (ss_song != NULL) {
  95                 free(ss_song);
  96                 ss_song = NULL;
  97         }
  98
  99         n_ss_ev = 0;
 100
 101         /* sorts the song */
 102         song_sort();
 103
 104         fpw = 0;
 105         frame = frame_ac = f_frame = 0;
 106         time_ac = time_ac_m = 0;
 107         num = den = 4;
 108
 109         /* travels the song events generating softsynth song events */
 110         for (n = 0; n < n_song_ev; n++) {
 111                 /* gets the song event */
 112                 e = &song[n];
 113
 114                 /* calculates the frame */
 115                 frame = ((e->time - time_ac) * fpw) + frame_ac;
 116                 e->frame = frame;
 117
 118                 switch (e->type) {
 119                 case SONG_EV_TEMPO:
 120
 121                         /* updates accumulations */
 122                         frame_ac = frame;
 123                         time_ac = e->time;
 124
 125                         /* calculates frames-per-whole based on new tempo */
 126                         fpw = (double) ss_frequency * 60.0;
 127                         fpw /= e->amount / 4.0;
 128
 129                         add_ss_ev(e);
 130
 131                         break;
 132
 133                 case SONG_EV_METER:
 134
 135                         /* just store the values */
 136                         num = e->min;
 137                         den = e->max;
 138                         time_ac_m = e->time;
 139
 140                         break;
 141
 142                 case SONG_EV_MEASURE:
 143
 144                         song_test_measure_boundary(e->time - time_ac_m,
 145                                                    num, den, e->value);
 146                         break;
 147
 148                 case SONG_EV_NOTE:
 149
 150                         /* assign a note id */
 151                         e->note_id = note_id++;
 152
 153                         /* copy */
 154                         add_ss_ev(e);
 155
 156                         /* copy again, but set as NOTE_OFF */
 157                         e = add_ss_ev(e);
 158                         e->type = SONG_EV_NOTE_OFF;
 159
 160                         frame += (int) (e->len * fpw);
 161                         e->frame = frame;
 162
 163                         break;
 164
 165                 case SONG_EV_BACK:
 166
 167                         /* move the cursor back */
 168
 169                         frame_ac -= (int) (e->len * fpw);
 170
 171                         break;
 172
 173                 case SONG_EV_SS_PITCH_STRETCH:
 174
 175                         /* assign a note id */
 176                         e->note_id = note_id++;
 177
 178                         /* copy */
 179                         add_ss_ev(e);
 180
 181                         /* and copy again, as a note off */
 182                         e = add_ss_ev(e);
 183                         e->type = SONG_EV_NOTE_OFF;
 184
 185                         frame += (int) (e->len * fpw);
 186                         e->frame = frame;
 187
 188                         break;
 189
 190                 case SONG_EV_SS_PRINT_WAVE_TEMPO:
 191                 case SONG_EV_SS_WAV:
 192                 case SONG_EV_SS_PAT:
 193                 case SONG_EV_SS_SUSTAIN:
 194                 case SONG_EV_SS_ATTACK:
 195                 case SONG_EV_SS_VIBRATO:
 196                 case SONG_EV_SS_PORTAMENTO:
 197                 case SONG_EV_SS_EFF_DELAY:
 198                 case SONG_EV_SS_EFF_ECHO:
 199                 case SONG_EV_SS_EFF_COMB:
 200                 case SONG_EV_SS_EFF_ALLPASS:
 201                 case SONG_EV_SS_EFF_FLANGER:
 202                 case SONG_EV_SS_EFF_WOBBLE:
 203                 case SONG_EV_SS_EFF_SQWOBBLE:
 204                 case SONG_EV_SS_EFF_HFWOBBLE:
 205                 case SONG_EV_SS_EFF_FADER:
 206                 case SONG_EV_SS_EFF_REVERB:
 207                 case SONG_EV_SS_EFF_FOLDBACK:
 208                 case SONG_EV_SS_EFF_ATAN:
 209                 case SONG_EV_SS_EFF_DISTORT:
 210                 case SONG_EV_SS_EFF_OVERDRIVE:
 211                 case SONG_EV_SS_EFF_OFF:
 212                 case SONG_EV_SONG_INFO:
 213                 case SONG_EV_EOT:
 214
 215                         /* just copy */
 216                         add_ss_ev(e);
 217                         break;
 218
 219                 case SONG_EV_SS_CHANNEL:
 220
 221                         /* count channels */
 222                         if (*n_channels < e->channel)
 223                                 *n_channels = e->channel;
 224
 225                         add_ss_ev(e);
 226                         break;
 227
 228                 case SONG_EV_NOP:
 229                 case SONG_EV_MIDI_CHANNEL:
 230                 case SONG_EV_MIDI_PROGRAM:
 231
 232                         /* ignored */
 233                         break;
 234
 235                 case SONG_EV_NOTE_OFF:
 236                 case SONG_EV_END:
 237
 238                         /* never found in generic song streams */
 239                         break;
 240                 }
 241
 242                 /* store the further frame seen */
 243                 if (f_frame < frame)
 244                         f_frame = frame;
 245         }
 246
 247         /* generates an end of event mark, a time after the last one */
 248         e = add_event(&ss_song, &n_ss_ev);
 249
 250         e->type = SONG_EV_END;
 251         e->frame = f_frame + ss_frequency;
 252         e->event_id = -1;
 253
 254         /* finally sort */
 255         qsort(ss_song, n_ss_ev, sizeof(struct song_ev), frame_type_eventid_cmp);
 256
 257         /* count one more */
 258         (*n_channels)++;
 259 }
 260
 261
 262 static const struct song_ev *process_this_frame_events(const struct song_ev *e, int skip_frames)
 263 /* process the events attached to this frame */
 264 {
 265         static double tempo = 120.0;
 266         static int frame = 0;
 267
 268         /* from the beginning? */
 269         if (e == NULL) {
 270                 e = ss_song;
 271                 tempo = 120.0;
 272                 frame = 0;
 273         }
 274
 275         if (verbose >= 1 && frame % ss_frequency == 0) {
 276                 int m = frame / ss_frequency;
 277                 printf("[%02d:%02d]\r", m / 60, m % 60);
 278                 fflush(stdout);
 279         }
 280
 281         while (e != NULL && e->frame == frame) {
 282                 struct ss_ins *i;
 283                 struct ss_wave *w;
 284                 double freq;
 285
 286                 if (e->type == SONG_EV_NOTE ||
 287                     e->type == SONG_EV_NOTE_OFF ||
 288                     e->type == SONG_EV_SS_PITCH_STRETCH) {
 289                         if (frame < skip_frames) {
 290                                 e++;
 291                                 frame = e->frame;
 292                                 continue;
 293                         }
 294                 }
 295
 296                 /* take the instrument */
 297                 if (e->trk_id < 0)
 298                         i = NULL;
 299                 else
 300                         i = &ss_song_ins[e->trk_id];
 301
 302                 switch (e->type) {
 303                 case SONG_EV_NOTE:
 304
 305                         if (ss_ins_note_on(i, e->value, e->vol, e->note_id) < 0 &&
 306                             verbose >= 1)
 307                                 printf("ss_ins_note_on error: track %d note %d\n",
 308                                        e->trk_id, e->value);
 309
 310                         break;
 311
 312                 case SONG_EV_NOTE_OFF:
 313
 314                         ss_ins_note_off(i, e->note_id);
 315
 316                         break;
 317
 318                 case SONG_EV_SS_SUSTAIN:
 319
 320                         ss_ins_set_sustain(i, e->amount);
 321
 322                         break;
 323
 324                 case SONG_EV_SS_ATTACK:
 325
 326                         ss_ins_set_attack(i, e->amount);
 327
 328                         break;
 329
 330                 case SONG_EV_SS_VIBRATO:
 331
 332                         ss_ins_set_vibrato(i, e->depth, e->freq);
 333
 334                         break;
 335
 336                 case SONG_EV_SS_PORTAMENTO:
 337
 338                         ss_ins_set_portamento(i, (e->amount * 44100.0)
 339                                               / ((double) ss_frequency * 1000000.0));
 340
 341                         break;
 342
 343                 case SONG_EV_SS_CHANNEL:
 344
 345                         ss_ins_set_channel(i, e->channel, e->vol);
 346
 347                         break;
 348
 349                 case SONG_EV_SS_WAV:
 350
 351                         w = ss_load_wav_file(e->name,
 352                                              ss_note_frequency(e->value),
 353                                              ss_note_frequency(e->min),
 354                                              ss_note_frequency(e->max),
 355                                              e->start, e->end,
 356                                              e->channel, e->skip_channels);
 357
 358                         /* fail if can't open wav */
 359                         if (w == NULL) {
 360                                 printf("Can't load wav '%s'\n", e->name);
 361                                 e = NULL;
 362                         }
 363                         else
 364                                 ss_ins_add_layer(i, w);
 365
 366                         break;
 367
 368                 case SONG_EV_SS_PAT:
 369
 370                         if (ss_load_pat_file(i, e->name) < 0) {
 371                                 printf("Can't load pat '%s'\n", e->name);
 372                                 e = NULL;
 373                         }
 374
 375                         break;
 376
 377                 case SONG_EV_SS_EFF_DELAY:
 378
 379                         ss_eff_delay(&i->effs[e->channel], e->len);
 380                         break;
 381
 382                 case SONG_EV_SS_EFF_ECHO:
 383
 384                         ss_eff_echo(&i->effs[e->channel], e->len, e->vol);
 385                         break;
 386
 387                 case SONG_EV_SS_EFF_COMB:
 388
 389                         ss_eff_comb(&i->effs[e->channel], e->len, e->vol);
 390                         break;
 391
 392                 case SONG_EV_SS_EFF_ALLPASS:
 393
 394                         ss_eff_allpass(&i->effs[e->channel], e->len, e->vol);
 395                         break;
 396
 397                 case SONG_EV_SS_EFF_FLANGER:
 398
 399                         ss_eff_flanger(&i->effs[e->channel],
 400                                        e->len, e->vol, e->depth, e->freq, e->phase);
 401                         break;
 402
 403                 case SONG_EV_SS_EFF_WOBBLE:
 404
 405                         ss_eff_wobble(&i->effs[e->channel], e->freq, e->phase, e->vol);
 406
 407                         break;
 408
 409                 case SONG_EV_SS_EFF_SQWOBBLE:
 410
 411                         ss_eff_square_wobble(&i->effs[e->channel], e->freq, e->phase);
 412
 413                         break;
 414
 415                 case SONG_EV_SS_EFF_HFWOBBLE:
 416
 417                         ss_eff_half_wobble(&i->effs[e->channel], e->freq, e->phase);
 418
 419                         break;
 420
 421                 case SONG_EV_SS_EFF_FADER:
 422
 423                         ss_eff_fader(&i->effs[e->channel], e->len, e->initial, e->final);
 424                         break;
 425
 426                 case SONG_EV_SS_EFF_REVERB:
 427
 428                         ss_eff_reverb(&i->effs[e->channel]);
 429                         break;
 430
 431                 case SONG_EV_SS_EFF_FOLDBACK:
 432
 433                         ss_eff_foldback(&i->effs[e->channel], e->vol);
 434                         break;
 435
 436                 case SONG_EV_SS_EFF_ATAN:
 437
 438                         ss_eff_atan(&i->effs[e->channel], e->vol);
 439                         break;
 440
 441                 case SONG_EV_SS_EFF_DISTORT:
 442
 443                         ss_eff_distort(&i->effs[e->channel], e->vol);
 444                         break;
 445
 446                 case SONG_EV_SS_EFF_OVERDRIVE:
 447
 448                         ss_eff_overdrive(&i->effs[e->channel], e->vol);
 449                         break;
 450
 451                 case SONG_EV_SS_EFF_OFF:
 452
 453                         ss_eff_off(&i->effs[e->channel]);
 454                         break;
 455
 456                 case SONG_EV_TEMPO:
 457
 458                         /* just store the last tempo */
 459                         tempo = e->amount;
 460                         break;
 461
 462                 case SONG_EV_SS_PITCH_STRETCH:
 463
 464                         /* find the wave */
 465                         freq = ss_note_frequency(e->value);
 466                         w = ss_ins_find_layer(i, freq, NULL);
 467
 468                         /* calculate optimal frequency */
 469                         freq = ss_pitch_from_tempo(w, tempo, e->len);
 470
 471                         /* play the note */
 472                         if (ss_ins_play(i, freq, e->vol,
 473                                         e->note_id, w) < 0 && verbose >= 1)
 474                                 printf("ss_ins_play error: track %d freq %f\n",
 475                                        e->trk_id, freq);
 476
 477                         break;
 478
 479                 case SONG_EV_SS_PRINT_WAVE_TEMPO:
 480
 481                         /* find the wave */
 482                         freq = ss_note_frequency(e->value);
 483                         w = ss_ins_find_layer(i, freq, NULL);
 484
 485                         /* print the optimal tempo */
 486                         printf("Optimal tempo: %lf\n",
 487                                ss_tempo_from_wave(w, e->value, e->len));
 488
 489                         break;
 490
 491                 case SONG_EV_SONG_INFO:
 492
 493                         /* add a new song (track) */
 494                         cue_file_song_info(frame, e->author, e->name);
 495                         break;
 496
 497                 case SONG_EV_EOT:
 498
 499                         /* end of track; trigger possible cleaning */
 500                         ss_ins_disable(i);
 501                         break;
 502
 503                 case SONG_EV_END:
 504
 505                         e = NULL;
 506                         break;
 507
 508                 case SONG_EV_BACK:
 509                 case SONG_EV_MIDI_CHANNEL:
 510                 case SONG_EV_MIDI_PROGRAM:
 511                 case SONG_EV_METER:
 512                 case SONG_EV_MEASURE:
 513                 case SONG_EV_NOP:
 514
 515                         /* never found in ss song streams */
 516                         break;
 517                 }
 518
 519                 /* next event */
 520                 if (e)
 521                         e++;
 522         }
 523
 524         frame++;
 525
 526         return e;
 527 }
 528
 529
 530 int ss_song_render(int skip_secs, const char *driver, const char *devfile)
 531 {
 532         int n, i = 0;
 533         sample_t output[SS_MAX_CHANNELS];
 534         int skip_frames;
 535         int n_channels;
 536         const struct song_ev *e = NULL;
 537
 538         /* convert the song to ss events */
 539         ss_song_convert_events(&n_channels);
 540
 541         if (verbose >= 2)
 542                 printf("Tracks: %d Channels: %d Events: %d\n",
 543                        n_song_tracks, n_channels, n_ss_ev);
 544
 545         if (trace) {
 546                 printf("** SOFTWARE SYNTHESIZER EVENT DUMP **\n\n");
 547                 dump_song_events(ss_song, n_ss_ev);
 548                 return 0;
 549         }
 550
 551         /* set the number of channels, unless forced */
 552         if (ss_nchannels == -1)
 553                 ss_nchannels = n_channels > 0 ? n_channels : 2;
 554
 555         if (ss_output_open(driver, devfile) < 0) {
 556                 printf("Error: can't init driver\n");
 557                 return 2;
 558         }
 559
 560         /* init the generators */
 561         ss_gen_init();
 562
 563         /* init the instruments */
 564         for (n = 0; n < n_song_tracks; n++)
 565                 ss_ins_init(&ss_song_ins[n]);
 566
 567         /* calculate the frame to start playing */
 568         skip_frames = skip_secs * ss_frequency;
 569
 570         /* main loop */
 571         do {
 572                 /* process all events in this frame */
 573                 e = process_this_frame_events(e, skip_frames);
 574
 575                 /* reset frame samples */
 576                 ss_output_init_frame(output);
 577
 578                 /* generate output from all instruments */
 579                 for (n = i = 0; n < n_song_tracks; n++)
 580                         i += ss_ins_frame(&ss_song_ins[n], output);
 581
 582                 /* dump to sampling driver */
 583                 ss_output_write(output);
 584         } while (i);
 585
 586         if (verbose >= 1)
 587                 printf("\n");
 588
 589         ss_output_close();
 590
 591         return 0;
 592 }