ss_song.c

   1 /*
   2
   3     Ann Hell Ex Machina - Music Software
   4     Copyright (C) 2003/2008 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_SF2:
 194                 case SONG_EV_SS_SUSTAIN:
 195                 case SONG_EV_SS_ATTACK:
 196                 case SONG_EV_SS_VIBRATO:
 197                 case SONG_EV_SS_PORTAMENTO:
 198                 case SONG_EV_SS_EFF_DELAY:
 199                 case SONG_EV_SS_EFF_ECHO:
 200                 case SONG_EV_SS_EFF_COMB:
 201                 case SONG_EV_SS_EFF_ALLPASS:
 202                 case SONG_EV_SS_EFF_FLANGER:
 203                 case SONG_EV_SS_EFF_WOBBLE:
 204                 case SONG_EV_SS_EFF_SQWOBBLE:
 205                 case SONG_EV_SS_EFF_HFWOBBLE:
 206                 case SONG_EV_SS_EFF_FADER:
 207                 case SONG_EV_SS_EFF_REVERB:
 208                 case SONG_EV_SS_EFF_FOLDBACK:
 209                 case SONG_EV_SS_EFF_ATAN:
 210                 case SONG_EV_SS_EFF_DISTORT:
 211                 case SONG_EV_SS_EFF_OVERDRIVE:
 212                 case SONG_EV_SS_EFF_OFF:
 213                 case SONG_EV_SS_MASTER_VOLUME:
 214                 case SONG_EV_SONG_INFO:
 215                 case SONG_EV_EOT:
 216
 217                         /* just copy */
 218                         add_ss_ev(e);
 219                         break;
 220
 221                 case SONG_EV_SS_CHANNEL:
 222
 223                         /* count channels */
 224                         if (*n_channels < e->channel)
 225                                 *n_channels = e->channel;
 226
 227                         add_ss_ev(e);
 228                         break;
 229
 230                 case SONG_EV_NOP:
 231                 case SONG_EV_MIDI_CHANNEL:
 232                 case SONG_EV_MIDI_PROGRAM:
 233
 234                         /* ignored */
 235                         break;
 236
 237                 case SONG_EV_NOTE_OFF:
 238                 case SONG_EV_END:
 239
 240                         /* never found in generic song streams */
 241                         break;
 242                 }
 243
 244                 /* store the further frame seen */
 245                 if (f_frame < frame)
 246                         f_frame = frame;
 247         }
 248
 249         /* generates an end of event mark, a time after the last one */
 250         e = add_event(&ss_song, &n_ss_ev);
 251
 252         e->type = SONG_EV_END;
 253         e->frame = f_frame + ss_frequency;
 254         e->event_id = -1;
 255
 256         /* finally sort */
 257         qsort(ss_song, n_ss_ev, sizeof(struct song_ev), frame_type_eventid_cmp);
 258
 259         /* count one more */
 260         (*n_channels)++;
 261 }
 262
 263
 264 static const struct song_ev *process_this_frame_events(const struct song_ev *e, int skip_frames)
 265 /* process the events attached to this frame */
 266 {
 267         static double tempo = 120.0;
 268         static int frame = 0;
 269
 270         /* from the beginning? */
 271         if (e == NULL) {
 272                 e = ss_song;
 273                 tempo = 120.0;
 274                 frame = 0;
 275         }
 276
 277         if (verbose >= 1 && frame % ss_frequency == 0) {
 278                 int m = frame / ss_frequency;
 279                 printf("[%02d:%02d]\r", m / 60, m % 60);
 280                 fflush(stdout);
 281         }
 282
 283         while (e != NULL && e->frame == frame) {
 284                 struct ss_ins *i;
 285                 struct ss_wave *w;
 286                 double freq;
 287
 288                 if (e->type == SONG_EV_NOTE ||
 289                     e->type == SONG_EV_NOTE_OFF ||
 290                     e->type == SONG_EV_SS_PITCH_STRETCH) {
 291                         if (frame < skip_frames) {
 292                                 e++;
 293                                 frame = e->frame;
 294                                 continue;
 295                         }
 296                 }
 297
 298                 /* take the instrument */
 299                 if (e->trk_id < 0)
 300                         i = NULL;
 301                 else
 302                         i = &ss_song_ins[e->trk_id];
 303
 304                 switch (e->type) {
 305                 case SONG_EV_NOTE:
 306
 307                         if (ss_ins_note_on(i, e->value, e->vol, e->note_id) < 0 &&
 308                             verbose >= 1)
 309                                 printf("ss_ins_note_on error: track %d note %d\n",
 310                                        e->trk_id, e->value);
 311
 312                         break;
 313
 314                 case SONG_EV_NOTE_OFF:
 315
 316                         ss_ins_note_off(i, e->note_id);
 317
 318                         break;
 319
 320                 case SONG_EV_SS_SUSTAIN:
 321
 322                         ss_ins_set_sustain(i, e->amount);
 323
 324                         break;
 325
 326                 case SONG_EV_SS_ATTACK:
 327
 328                         ss_ins_set_attack(i, e->amount);
 329
 330                         break;
 331
 332                 case SONG_EV_SS_VIBRATO:
 333
 334                         ss_ins_set_vibrato(i, e->depth, e->freq);
 335
 336                         break;
 337
 338                 case SONG_EV_SS_PORTAMENTO:
 339
 340                         ss_ins_set_portamento(i, (e->amount * 44100.0)
 341                                               / ((double) ss_frequency * 1000000.0));
 342
 343                         break;
 344
 345                 case SONG_EV_SS_CHANNEL:
 346
 347                         ss_ins_set_channel(i, e->channel, e->vol);
 348
 349                         break;
 350
 351                 case SONG_EV_SS_WAV:
 352
 353                         w = ss_load_wav_file(e->name,
 354                                              ss_note_frequency(e->value),
 355                                              ss_note_frequency(e->min),
 356                                              ss_note_frequency(e->max),
 357                                              e->start, e->end,
 358                                              e->channel, e->skip_channels);
 359
 360                         /* fail if can't open wav */
 361                         if (w == NULL) {
 362                                 printf("Can't load wav '%s'\n", e->name);
 363                                 e = NULL;
 364                         }
 365                         else
 366                                 ss_ins_add_layer(i, w);
 367
 368                         break;
 369
 370                 case SONG_EV_SS_PAT:
 371
 372                         if (ss_load_pat_file(i, e->name) < 0) {
 373                                 printf("Can't load pat '%s'\n", e->name);
 374                                 e = NULL;
 375                         }
 376
 377                         break;
 378
 379                 case SONG_EV_SS_SF2:
 380
 381                         if (ss_load_sf2_file(i, e->name, e->str2) < 0) {
 382                                 printf("Can't load instrument from sf2 '%s'\n", e->name);
 383                                 e = NULL;
 384                         }
 385
 386                         break;
 387
 388                 case SONG_EV_SS_EFF_DELAY:
 389
 390                         ss_eff_delay(&i->effs[e->channel], e->len);
 391                         break;
 392
 393                 case SONG_EV_SS_EFF_ECHO:
 394
 395                         ss_eff_echo(&i->effs[e->channel], e->len, e->vol);
 396                         break;
 397
 398                 case SONG_EV_SS_EFF_COMB:
 399
 400                         ss_eff_comb(&i->effs[e->channel], e->len, e->vol);
 401                         break;
 402
 403                 case SONG_EV_SS_EFF_ALLPASS:
 404
 405                         ss_eff_allpass(&i->effs[e->channel], e->len, e->vol);
 406                         break;
 407
 408                 case SONG_EV_SS_EFF_FLANGER:
 409
 410                         ss_eff_flanger(&i->effs[e->channel],
 411                                        e->len, e->vol, e->depth, e->freq, e->phase);
 412                         break;
 413
 414                 case SONG_EV_SS_EFF_WOBBLE:
 415
 416                         ss_eff_wobble(&i->effs[e->channel], e->freq, e->phase, e->vol);
 417
 418                         break;
 419
 420                 case SONG_EV_SS_EFF_SQWOBBLE:
 421
 422                         ss_eff_square_wobble(&i->effs[e->channel], e->freq, e->phase);
 423
 424                         break;
 425
 426                 case SONG_EV_SS_EFF_HFWOBBLE:
 427
 428                         ss_eff_half_wobble(&i->effs[e->channel], e->freq, e->phase);
 429
 430                         break;
 431
 432                 case SONG_EV_SS_EFF_FADER:
 433
 434                         ss_eff_fader(&i->effs[e->channel], e->len, e->initial, e->final);
 435                         break;
 436
 437                 case SONG_EV_SS_EFF_REVERB:
 438
 439                         ss_eff_reverb(&i->effs[e->channel]);
 440                         break;
 441
 442                 case SONG_EV_SS_EFF_FOLDBACK:
 443
 444                         ss_eff_foldback(&i->effs[e->channel], e->vol);
 445                         break;
 446
 447                 case SONG_EV_SS_EFF_ATAN:
 448
 449                         ss_eff_atan(&i->effs[e->channel], e->vol);
 450                         break;
 451
 452                 case SONG_EV_SS_EFF_DISTORT:
 453
 454                         ss_eff_distort(&i->effs[e->channel], e->vol);
 455                         break;
 456
 457                 case SONG_EV_SS_EFF_OVERDRIVE:
 458
 459                         ss_eff_overdrive(&i->effs[e->channel], e->vol);
 460                         break;
 461
 462                 case SONG_EV_SS_EFF_OFF:
 463
 464                         ss_eff_off(&i->effs[e->channel]);
 465                         break;
 466
 467                 case SONG_EV_TEMPO:
 468
 469                         /* just store the last tempo */
 470                         tempo = e->amount;
 471                         break;
 472
 473                 case SONG_EV_SS_PITCH_STRETCH:
 474
 475                         /* find the wave */
 476                         freq = ss_note_frequency(e->value);
 477                         w = ss_ins_find_layer(i, freq, NULL);
 478
 479                         /* calculate optimal frequency */
 480                         freq = ss_pitch_from_tempo(w, tempo, e->len);
 481
 482                         /* play the note */
 483                         if (ss_ins_play(i, freq, e->vol,
 484                                         e->note_id, w) < 0 && verbose >= 1)
 485                                 printf("ss_ins_play error: track %d freq %f\n",
 486                                        e->trk_id, freq);
 487
 488                         break;
 489
 490                 case SONG_EV_SS_PRINT_WAVE_TEMPO:
 491
 492                         /* find the wave */
 493                         freq = ss_note_frequency(e->value);
 494                         w = ss_ins_find_layer(i, freq, NULL);
 495
 496                         /* print the optimal tempo */
 497                         printf("Optimal tempo: %lf\n",
 498                                ss_tempo_from_wave(w, e->value, e->len));
 499
 500                         break;
 501
 502                 case SONG_EV_SS_MASTER_VOLUME:
 503
 504                         /* set master volume */
 505                         ss_master_volume = e->vol;
 506                         break;
 507
 508                 case SONG_EV_SONG_INFO:
 509
 510                         /* add a new song (track) */
 511                         cue_file_song_info(frame, e->str2, e->name);
 512                         break;
 513
 514                 case SONG_EV_EOT:
 515
 516                         /* end of track; trigger possible cleaning */
 517                         ss_ins_disable(i);
 518                         break;
 519
 520                 case SONG_EV_END:
 521
 522                         e = NULL;
 523                         break;
 524
 525                 case SONG_EV_BACK:
 526                 case SONG_EV_MIDI_CHANNEL:
 527                 case SONG_EV_MIDI_PROGRAM:
 528                 case SONG_EV_METER:
 529                 case SONG_EV_MEASURE:
 530                 case SONG_EV_NOP:
 531
 532                         /* never found in ss song streams */
 533                         break;
 534                 }
 535
 536                 /* next event */
 537                 if (e)
 538                         e++;
 539         }
 540
 541         frame++;
 542
 543         return e;
 544 }
 545
 546
 547 int ss_song_render(int skip_secs, const char *driver, const char *devfile)
 548 {
 549         int n, i = 0;
 550         sample_t output[SS_MAX_CHANNELS];
 551         int skip_frames;
 552         int n_channels;
 553         const struct song_ev *e = NULL;
 554
 555         /* convert the song to ss events */
 556         ss_song_convert_events(&n_channels);
 557
 558         if (verbose >= 2)
 559                 printf("Tracks: %d Channels: %d Events: %d\n",
 560                        n_song_tracks, n_channels, n_ss_ev);
 561
 562         if (trace) {
 563                 printf("** SOFTWARE SYNTHESIZER EVENT DUMP **\n\n");
 564                 dump_song_events(ss_song, n_ss_ev);
 565                 return 0;
 566         }
 567
 568         /* set the number of channels, unless forced */
 569         if (ss_nchannels == -1)
 570                 ss_nchannels = n_channels > 0 ? n_channels : 2;
 571
 572         if (ss_output_open(driver, devfile) < 0) {
 573                 printf("Error: can't init driver\n");
 574                 return 2;
 575         }
 576
 577         /* init the generators */
 578         ss_gen_init();
 579
 580         /* init the instruments */
 581         for (n = 0; n < n_song_tracks; n++)
 582                 ss_ins_init(&ss_song_ins[n]);
 583
 584         /* calculate the frame to start playing */
 585         skip_frames = skip_secs * ss_frequency;
 586
 587         /* main loop */
 588         do {
 589                 /* process all events in this frame */
 590                 e = process_this_frame_events(e, skip_frames);
 591
 592                 /* reset frame samples */
 593                 ss_output_init_frame(output);
 594
 595                 /* generate output from all instruments */
 596                 for (n = i = 0; n < n_song_tracks; n++)
 597                         i += ss_ins_frame(&ss_song_ins[n], output);
 598
 599                 /* dump to sampling driver */
 600                 ss_output_write(output);
 601         } while (i);
 602
 603         if (verbose >= 1)
 604                 printf("\n");
 605
 606         ss_output_close();
 607
 608         return 0;
 609 }